go/json-iterator
1
0
Fork 0
mirror of https://github.com/json-iterator/go.git synced 2025-06-15 22:50:24 +02:00
Code Issues Releases Activity

Compare commits

base: go:jsoniter-go-0.9.14
Branches Tags
go:master go:revert-55-output_tests
go:v1.1.12 go:v1.1.11 go:v1.1.10 go:v1.1.9 go:1.1.8 go:v1.1.8 go:v1.1.7 go:v1.1.6 go:1.1.5 go:v1.1.5 go:1.1.4 go:1.1.3 go:1.1.2 go:1.1.1 go:1.1.0 go:1.0.6 go:1.0.5 go:1.0.4 go:1.0.3 go:1.0.2 go:1.0.1 go:1.0.0 go:jsoniter-go-0.9.19 go:jsoniter-go-0.9.18 go:jsoniter-go-0.9.17 go:jsoniter-go-0.9.16 go:jsoniter-go-0.9.15 go:jsoniter-go-0.9.14 go:jsoniter-go-0.9.13 go:jsoniter-go-0.9.8 go:jsoniter-go-0.9.2
..
compare: go:revert-55-output_tests
Branches Tags
go:master go:revert-55-output_tests
go:v1.1.12 go:v1.1.11 go:v1.1.10 go:v1.1.9 go:1.1.8 go:v1.1.8 go:v1.1.7 go:v1.1.6 go:1.1.5 go:v1.1.5 go:1.1.4 go:1.1.3 go:1.1.2 go:1.1.1 go:1.1.0 go:1.0.6 go:1.0.5 go:1.0.4 go:1.0.3 go:1.0.2 go:1.0.1 go:1.0.0 go:jsoniter-go-0.9.19 go:jsoniter-go-0.9.18 go:jsoniter-go-0.9.17 go:jsoniter-go-0.9.16 go:jsoniter-go-0.9.15 go:jsoniter-go-0.9.14 go:jsoniter-go-0.9.13 go:jsoniter-go-0.9.8 go:jsoniter-go-0.9.2

1 Commits
jsoniter-g ... revert-55-

Author SHA1 Message Date
Tao Wen
787edc95b0 Revert "WIP: Tests to compare against stdlib" 2017-06-12 15:07:52 +08:00
186 changed files with 567 additions and 11924 deletions
Expand all files Collapse all files

92
feature_adapter.go
View File

@ -14,7 +14,9 @@ package jsoniter
import (
"bytes"
"encoding/json"
"errors"
"io"
"reflect"
"unsafe"
)
@ -23,12 +25,41 @@ import (
// Unmarshal parses the JSON-encoded data and stores the result in the value pointed to by v.
// Refer to https://godoc.org/encoding/json#Unmarshal for more information
func Unmarshal(data []byte, v interface{}) error {
return ConfigOfDefault.Unmarshal(data, v)
data = data[:lastNotSpacePos(data)]
iter := ParseBytes(data)
typ := reflect.TypeOf(v)
if typ.Kind() != reflect.Ptr {
// return non-pointer error
return errors.New("the second param must be ptr type")
}
iter.ReadVal(v)
if iter.head == iter.tail {
iter.loadMore()
}
if iter.Error == io.EOF {
return nil
}
if iter.Error == nil {
iter.reportError("Unmarshal", "there are bytes left after unmarshal")
}
return iter.Error
}
// UnmarshalAny adapts to
func UnmarshalAny(data []byte) (Any, error) {
return ConfigOfDefault.UnmarshalAny(data)
data = data[:lastNotSpacePos(data)]
iter := ParseBytes(data)
any := iter.ReadAny()
if iter.head == iter.tail {
iter.loadMore()
}
if iter.Error == io.EOF {
return any, nil
}
if iter.Error == nil {
iter.reportError("UnmarshalAny", "there are bytes left after unmarshal")
}
return any, iter.Error
}
func lastNotSpacePos(data []byte) int {
@ -41,11 +72,37 @@ func lastNotSpacePos(data []byte) int {
}
func UnmarshalFromString(str string, v interface{}) error {
return ConfigOfDefault.UnmarshalFromString(str, v)
data := []byte(str)
data = data[:lastNotSpacePos(data)]
iter := ParseBytes(data)
iter.ReadVal(v)
if iter.head == iter.tail {
iter.loadMore()
}
if iter.Error == io.EOF {
return nil
}
if iter.Error == nil {
iter.reportError("UnmarshalFromString", "there are bytes left after unmarshal")
}
return iter.Error
}
func UnmarshalAnyFromString(str string) (Any, error) {
return ConfigOfDefault.UnmarshalAnyFromString(str)
data := []byte(str)
data = data[:lastNotSpacePos(data)]
iter := ParseBytes(data)
any := iter.ReadAny()
if iter.head == iter.tail {
iter.loadMore()
}
if iter.Error == io.EOF {
return any, nil
}
if iter.Error == nil {
iter.reportError("UnmarshalAnyFromString", "there are bytes left after unmarshal")
}
return nil, iter.Error
}
// Marshal adapts to json/encoding Marshal API
@ -53,11 +110,20 @@ func UnmarshalAnyFromString(str string) (Any, error) {
// Marshal returns the JSON encoding of v, adapts to json/encoding Marshal API
// Refer to https://godoc.org/encoding/json#Marshal for more information
func Marshal(v interface{}) ([]byte, error) {
return ConfigOfDefault.Marshal(v)
stream := NewStream(nil, 256)
stream.WriteVal(v)
if stream.Error != nil {
return nil, stream.Error
}
return stream.Buffer(), nil
}
func MarshalToString(v interface{}) (string, error) {
return ConfigOfDefault.MarshalToString(v)
buf, err := Marshal(v)
if err != nil {
return "", err
}
return string(buf), nil
}
// NewDecoder adapts to json/stream NewDecoder API.
@ -67,7 +133,8 @@ func MarshalToString(v interface{}) (string, error) {
// Instead of a json/encoding Decoder, an AdaptedDecoder is returned
// Refer to https://godoc.org/encoding/json#NewDecoder for more information
func NewDecoder(reader io.Reader) *AdaptedDecoder {
return ConfigOfDefault.NewDecoder(reader)
iter := Parse(reader, 512)
return &AdaptedDecoder{iter}
}
// AdaptedDecoder reads and decodes JSON values from an input stream.
@ -105,7 +172,8 @@ func (decoder *AdaptedDecoder) UseNumber() {
}
func NewEncoder(writer io.Writer) *AdaptedEncoder {
return ConfigOfDefault.NewEncoder(writer)
stream := NewStream(writer, 512)
return &AdaptedEncoder{stream}
}
type AdaptedEncoder struct {
@ -119,11 +187,5 @@ func (adapter *AdaptedEncoder) Encode(val interface{}) error {
}
func (adapter *AdaptedEncoder) SetIndent(prefix, indent string) {
adapter.stream.cfg.indentionStep = len(indent)
}
func (adapter *AdaptedEncoder) SetEscapeHTML(escapeHtml bool) {
config := adapter.stream.cfg.configBeforeFrozen
config.EscapeHtml = escapeHtml
adapter.stream.cfg = config.Froze()
adapter.stream.IndentionStep = len(indent)
}

4
feature_any_array.go
View File

@ -22,7 +22,7 @@ func (any *arrayLazyAny) ValueType() ValueType {
func (any *arrayLazyAny) Parse() *Iterator {
iter := any.iter
if iter == nil {
iter = NewIterator(ConfigOfDefault)
iter = NewIterator()
any.iter = iter
}
iter.ResetBytes(any.remaining)
@ -287,7 +287,7 @@ func (any *arrayLazyAny) IterateArray() (func() (Any, bool), bool) {
// read from buffer
iter := any.iter
if iter == nil {
iter = NewIterator(ConfigOfDefault)
iter = NewIterator()
any.iter = iter
}
iter.ResetBytes(remaining)

2
feature_any_float.go
View File

@ -17,7 +17,7 @@ type float64LazyAny struct {
func (any *float64LazyAny) Parse() *Iterator {
iter := any.iter
if iter == nil {
iter = NewIterator(ConfigOfDefault)
iter = NewIterator()
}
iter.ResetBytes(any.buf)
return iter

2
feature_any_int64.go
View File

@ -21,7 +21,7 @@ func (any *int64LazyAny) ValueType() ValueType {
func (any *int64LazyAny) Parse() *Iterator {
iter := any.iter
if iter == nil {
iter = NewIterator(ConfigOfDefault)
iter = NewIterator()
}
iter.ResetBytes(any.buf)
return iter

4
feature_any_object.go
View File

@ -22,7 +22,7 @@ func (any *objectLazyAny) ValueType() ValueType {
func (any *objectLazyAny) Parse() *Iterator {
iter := any.iter
if iter == nil {
iter = NewIterator(ConfigOfDefault)
iter = NewIterator()
any.iter = iter
}
iter.ResetBytes(any.remaining)
@ -308,7 +308,7 @@ func (any *objectLazyAny) IterateObject() (func() (string, Any, bool), bool) {
// read from buffer
iter := any.iter
if iter == nil {
iter = NewIterator(ConfigOfDefault)
iter = NewIterator()
any.iter = iter
}
iter.ResetBytes(remaining)

2
feature_any_string.go
View File

@ -20,7 +20,7 @@ func (any *stringLazyAny) ValueType() ValueType {
func (any *stringLazyAny) Parse() *Iterator {
iter := any.iter
if iter == nil {
iter = NewIterator(ConfigOfDefault)
iter = NewIterator()
any.iter = iter
}
iter.ResetBytes(any.buf)

2
feature_any_uint64.go
View File

@ -21,7 +21,7 @@ func (any *uint64LazyAny) ValueType() ValueType {
func (any *uint64LazyAny) Parse() *Iterator {
iter := any.iter
if iter == nil {
iter = NewIterator(ConfigOfDefault)
iter = NewIterator()
}
iter.ResetBytes(any.buf)
return iter

239
feature_config.go
View File

@ -1,239 +0,0 @@
package jsoniter
import (
"io"
"reflect"
"sync/atomic"
"unsafe"
"errors"
)
type Config struct {
IndentionStep int
MarshalFloatWith6Digits bool
SupportUnexportedStructFields bool
EscapeHtml bool
SortMapKeys bool
}
type frozenConfig struct {
configBeforeFrozen Config
sortMapKeys bool
indentionStep int
decoderCache unsafe.Pointer
encoderCache unsafe.Pointer
extensions []ExtensionFunc
}
var ConfigOfDefault = Config{}.Froze()
// Trying to be 100% compatible with standard library behavior
var ConfigCompatibleWithStandardLibrary = Config{
EscapeHtml: true,
SortMapKeys: true,
}.Froze()
func (cfg Config) Froze() *frozenConfig {
frozenConfig := &frozenConfig{
sortMapKeys: cfg.SortMapKeys,
indentionStep: cfg.IndentionStep,
}
atomic.StorePointer(&frozenConfig.decoderCache, unsafe.Pointer(&map[string]Decoder{}))
atomic.StorePointer(&frozenConfig.encoderCache, unsafe.Pointer(&map[string]Encoder{}))
if cfg.MarshalFloatWith6Digits {
frozenConfig.marshalFloatWith6Digits()
}
if cfg.SupportUnexportedStructFields {
frozenConfig.supportUnexportedStructFields()
}
if cfg.EscapeHtml {
frozenConfig.escapeHtml()
}
frozenConfig.configBeforeFrozen = cfg
return frozenConfig
}
// RegisterExtension can register a custom extension
func (cfg *frozenConfig) registerExtension(extension ExtensionFunc) {
cfg.extensions = append(cfg.extensions, extension)
}
func (cfg *frozenConfig) supportUnexportedStructFields() {
cfg.registerExtension(func(type_ reflect.Type, field *reflect.StructField) ([]string, EncoderFunc, DecoderFunc) {
return []string{field.Name}, nil, nil
})
}
// EnableLossyFloatMarshalling keeps 10**(-6) precision
// for float variables for better performance.
func (cfg *frozenConfig) marshalFloatWith6Digits() {
// for better performance
cfg.addEncoderToCache(reflect.TypeOf((*float32)(nil)).Elem(), &funcEncoder{func(ptr unsafe.Pointer, stream *Stream) {
val := *((*float32)(ptr))
stream.WriteFloat32Lossy(val)
}})
cfg.addEncoderToCache(reflect.TypeOf((*float64)(nil)).Elem(), &funcEncoder{func(ptr unsafe.Pointer, stream *Stream) {
val := *((*float64)(ptr))
stream.WriteFloat64Lossy(val)
}})
}
func (cfg *frozenConfig) escapeHtml() {
// for better performance
cfg.addEncoderToCache(reflect.TypeOf((*string)(nil)).Elem(), &funcEncoder{func(ptr unsafe.Pointer, stream *Stream) {
val := *((*string)(ptr))
stream.WriteStringWithHtmlEscaped(val)
}})
}
func (cfg *frozenConfig) addDecoderToCache(cacheKey reflect.Type, decoder Decoder) {
done := false
for !done {
ptr := atomic.LoadPointer(&cfg.decoderCache)
cache := *(*map[reflect.Type]Decoder)(ptr)
copied := map[reflect.Type]Decoder{}
for k, v := range cache {
copied[k] = v
}
copied[cacheKey] = decoder
done = atomic.CompareAndSwapPointer(&cfg.decoderCache, ptr, unsafe.Pointer(&copied))
}
}
func (cfg *frozenConfig) addEncoderToCache(cacheKey reflect.Type, encoder Encoder) {
done := false
for !done {
ptr := atomic.LoadPointer(&cfg.encoderCache)
cache := *(*map[reflect.Type]Encoder)(ptr)
copied := map[reflect.Type]Encoder{}
for k, v := range cache {
copied[k] = v
}
copied[cacheKey] = encoder
done = atomic.CompareAndSwapPointer(&cfg.encoderCache, ptr, unsafe.Pointer(&copied))
}
}
func (cfg *frozenConfig) getDecoderFromCache(cacheKey reflect.Type) Decoder {
ptr := atomic.LoadPointer(&cfg.decoderCache)
cache := *(*map[reflect.Type]Decoder)(ptr)
return cache[cacheKey]
}
func (cfg *frozenConfig) getEncoderFromCache(cacheKey reflect.Type) Encoder {
ptr := atomic.LoadPointer(&cfg.encoderCache)
cache := *(*map[reflect.Type]Encoder)(ptr)
return cache[cacheKey]
}
// CleanDecoders cleans decoders registered or cached
func (cfg *frozenConfig) CleanDecoders() {
typeDecoders = map[string]Decoder{}
fieldDecoders = map[string]Decoder{}
atomic.StorePointer(&cfg.decoderCache, unsafe.Pointer(&map[string]Decoder{}))
}
// CleanEncoders cleans encoders registered or cached
func (cfg *frozenConfig) CleanEncoders() {
typeEncoders = map[string]Encoder{}
fieldEncoders = map[string]Encoder{}
atomic.StorePointer(&cfg.encoderCache, unsafe.Pointer(&map[string]Encoder{}))
}
func (cfg *frozenConfig) MarshalToString(v interface{}) (string, error) {
buf, err := cfg.Marshal(v)
if err != nil {
return "", err
}
return string(buf), nil
}
func (cfg *frozenConfig) Marshal(v interface{}) ([]byte, error) {
stream := NewStream(cfg, nil, 256)
stream.WriteVal(v)
if stream.Error != nil {
return nil, stream.Error
}
return stream.Buffer(), nil
}
func (cfg *frozenConfig) UnmarshalFromString(str string, v interface{}) error {
data := []byte(str)
data = data[:lastNotSpacePos(data)]
iter := ParseBytes(cfg, data)
iter.ReadVal(v)
if iter.head == iter.tail {
iter.loadMore()
}
if iter.Error == io.EOF {
return nil
}
if iter.Error == nil {
iter.reportError("UnmarshalFromString", "there are bytes left after unmarshal")
}
return iter.Error
}
func (cfg *frozenConfig) NewEncoder(writer io.Writer) *AdaptedEncoder {
stream := NewStream(cfg, writer, 512)
return &AdaptedEncoder{stream}
}
func (cfg *frozenConfig) NewDecoder(reader io.Reader) *AdaptedDecoder {
iter := Parse(cfg, reader, 512)
return &AdaptedDecoder{iter}
}
func (cfg *frozenConfig) UnmarshalAnyFromString(str string) (Any, error) {
data := []byte(str)
data = data[:lastNotSpacePos(data)]
iter := ParseBytes(cfg, data)
any := iter.ReadAny()
if iter.head == iter.tail {
iter.loadMore()
}
if iter.Error == io.EOF {
return any, nil
}
if iter.Error == nil {
iter.reportError("UnmarshalAnyFromString", "there are bytes left after unmarshal")
}
return nil, iter.Error
}
func (cfg *frozenConfig) UnmarshalAny(data []byte) (Any, error) {
data = data[:lastNotSpacePos(data)]
iter := ParseBytes(cfg, data)
any := iter.ReadAny()
if iter.head == iter.tail {
iter.loadMore()
}
if iter.Error == io.EOF {
return any, nil
}
if iter.Error == nil {
iter.reportError("UnmarshalAny", "there are bytes left after unmarshal")
}
return any, iter.Error
}
func (cfg *frozenConfig) Unmarshal(data []byte, v interface{}) error {
data = data[:lastNotSpacePos(data)]
iter := ParseBytes(cfg, data)
typ := reflect.TypeOf(v)
if typ.Kind() != reflect.Ptr {
// return non-pointer error
return errors.New("the second param must be ptr type")
}
iter.ReadVal(v)
if iter.head == iter.tail {
iter.loadMore()
}
if iter.Error == io.EOF {
return nil
}
if iter.Error == nil {
iter.reportError("Unmarshal", "there are bytes left after unmarshal")
}
return iter.Error
}

14
feature_iter.go
View File

@ -66,7 +66,6 @@ func init() {
// Iterator is a fast and flexible JSON parser
type Iterator struct {
cfg *frozenConfig
reader io.Reader
buf []byte
head int
@ -75,9 +74,8 @@ type Iterator struct {
}
// Create creates an empty Iterator instance
func NewIterator(cfg *frozenConfig) *Iterator {
func NewIterator() *Iterator {
return &Iterator{
cfg: cfg,
reader: nil,
buf: nil,
head: 0,
@ -86,9 +84,8 @@ func NewIterator(cfg *frozenConfig) *Iterator {
}
// Parse parses a json buffer in io.Reader into an Iterator instance
func Parse(cfg *frozenConfig, reader io.Reader, bufSize int) *Iterator {
func Parse(reader io.Reader, bufSize int) *Iterator {
return &Iterator{
cfg: cfg,
reader: reader,
buf: make([]byte, bufSize),
head: 0,
@ -97,9 +94,8 @@ func Parse(cfg *frozenConfig, reader io.Reader, bufSize int) *Iterator {
}
// ParseBytes parses a json byte slice into an Iterator instance
func ParseBytes(cfg *frozenConfig, input []byte) *Iterator {
func ParseBytes(input []byte) *Iterator {
return &Iterator{
cfg: cfg,
reader: nil,
buf: input,
head: 0,
@ -108,8 +104,8 @@ func ParseBytes(cfg *frozenConfig, input []byte) *Iterator {
}
// ParseString parses a json string into an Iterator instance
func ParseString(cfg *frozenConfig, input string) *Iterator {
return ParseBytes(cfg, []byte(input))
func ParseString(input string) *Iterator {
return ParseBytes([]byte(input))
}
// Reset can reset an Iterator instance for another json buffer in io.Reader

8
feature_iter_float.go
View File

@ -102,9 +102,9 @@ non_decimal_loop:
ind := floatDigits[c]
switch ind {
case endOfNumber:
if decimalPlaces > 0 && decimalPlaces < len(_POW10) {
if decimalPlaces > 0 && decimalPlaces < len(POW10) {
iter.head = i
return float32(float64(value) / float64(_POW10[decimalPlaces]))
return float32(float64(value) / float64(POW10[decimalPlaces]))
}
// too many decimal places
return iter.readFloat32SlowPath()
@ -205,9 +205,9 @@ non_decimal_loop:
ind := floatDigits[c]
switch ind {
case endOfNumber:
if decimalPlaces > 0 && decimalPlaces < len(_POW10) {
if decimalPlaces > 0 && decimalPlaces < len(POW10) {
iter.head = i
return float64(value) / float64(_POW10[decimalPlaces])
return float64(value) / float64(POW10[decimalPlaces])
}
// too many decimal places
return iter.readFloat64SlowPath()

144
feature_reflect.go
View File

@ -5,6 +5,7 @@ import (
"encoding/json"
"fmt"
"reflect"
"sync/atomic"
"unsafe"
)
@ -33,10 +34,6 @@ type Encoder interface {
func writeToStream(val interface{}, stream *Stream, encoder Encoder) {
e := (*emptyInterface)(unsafe.Pointer(&val))
if e.word == nil {
stream.WriteNil()
return
}
if reflect.TypeOf(val).Kind() == reflect.Ptr {
encoder.encode(unsafe.Pointer(&e.word), stream)
} else {
@ -72,6 +69,9 @@ func (encoder *funcEncoder) isEmpty(ptr unsafe.Pointer) bool {
return false
}
var DECODERS unsafe.Pointer
var ENCODERS unsafe.Pointer
var typeDecoders map[string]Decoder
var fieldDecoders map[string]Decoder
var typeEncoders map[string]Encoder
@ -90,6 +90,8 @@ func init() {
typeEncoders = map[string]Encoder{}
fieldEncoders = map[string]Encoder{}
extensions = []ExtensionFunc{}
atomic.StorePointer(&DECODERS, unsafe.Pointer(&map[string]Decoder{}))
atomic.StorePointer(&ENCODERS, unsafe.Pointer(&map[string]Encoder{}))
jsonNumberType = reflect.TypeOf((*json.Number)(nil)).Elem()
jsonRawMessageType = reflect.TypeOf((*json.RawMessage)(nil)).Elem()
anyType = reflect.TypeOf((*Any)(nil)).Elem()
@ -98,6 +100,46 @@ func init() {
textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
}
func addDecoderToCache(cacheKey reflect.Type, decoder Decoder) {
done := false
for !done {
ptr := atomic.LoadPointer(&DECODERS)
cache := *(*map[reflect.Type]Decoder)(ptr)
copied := map[reflect.Type]Decoder{}
for k, v := range cache {
copied[k] = v
}
copied[cacheKey] = decoder
done = atomic.CompareAndSwapPointer(&DECODERS, ptr, unsafe.Pointer(&copied))
}
}
func addEncoderToCache(cacheKey reflect.Type, encoder Encoder) {
done := false
for !done {
ptr := atomic.LoadPointer(&ENCODERS)
cache := *(*map[reflect.Type]Encoder)(ptr)
copied := map[reflect.Type]Encoder{}
for k, v := range cache {
copied[k] = v
}
copied[cacheKey] = encoder
done = atomic.CompareAndSwapPointer(&ENCODERS, ptr, unsafe.Pointer(&copied))
}
}
func getDecoderFromCache(cacheKey reflect.Type) Decoder {
ptr := atomic.LoadPointer(&DECODERS)
cache := *(*map[reflect.Type]Decoder)(ptr)
return cache[cacheKey]
}
func getEncoderFromCache(cacheKey reflect.Type) Encoder {
ptr := atomic.LoadPointer(&ENCODERS)
cache := *(*map[reflect.Type]Encoder)(ptr)
return cache[cacheKey]
}
// RegisterTypeDecoder can register a type for json object
func RegisterTypeDecoder(typ string, fun DecoderFunc) {
typeDecoders[typ] = &funcDecoder{fun}
@ -121,6 +163,20 @@ func RegisterExtension(extension ExtensionFunc) {
extensions = append(extensions, extension)
}
// CleanDecoders cleans decoders registered or cached
func CleanDecoders() {
typeDecoders = map[string]Decoder{}
fieldDecoders = map[string]Decoder{}
atomic.StorePointer(&DECODERS, unsafe.Pointer(&map[string]Decoder{}))
}
// CleanEncoders cleans encoders registered or cached
func CleanEncoders() {
typeEncoders = map[string]Encoder{}
fieldEncoders = map[string]Encoder{}
atomic.StorePointer(&ENCODERS, unsafe.Pointer(&map[string]Encoder{}))
}
type optionalDecoder struct {
valueType reflect.Type
valueDecoder Decoder
@ -214,15 +270,15 @@ type nonEmptyInterface struct {
func (iter *Iterator) ReadVal(obj interface{}) {
typ := reflect.TypeOf(obj)
cacheKey := typ.Elem()
cachedDecoder := iter.cfg.getDecoderFromCache(cacheKey)
cachedDecoder := getDecoderFromCache(cacheKey)
if cachedDecoder == nil {
decoder, err := decoderOfType(iter.cfg, cacheKey)
decoder, err := decoderOfType(cacheKey)
if err != nil {
iter.Error = err
return
}
cachedDecoder = decoder
iter.cfg.addDecoderToCache(cacheKey, decoder)
addDecoderToCache(cacheKey, decoder)
}
e := (*emptyInterface)(unsafe.Pointer(&obj))
cachedDecoder.decode(e.word, iter)
@ -235,15 +291,15 @@ func (stream *Stream) WriteVal(val interface{}) {
}
typ := reflect.TypeOf(val)
cacheKey := typ
cachedEncoder := stream.cfg.getEncoderFromCache(cacheKey)
cachedEncoder := getEncoderFromCache(cacheKey)
if cachedEncoder == nil {
encoder, err := encoderOfType(stream.cfg, cacheKey)
encoder, err := encoderOfType(cacheKey)
if err != nil {
stream.Error = err
return
}
cachedEncoder = encoder
stream.cfg.addEncoderToCache(cacheKey, encoder)
addEncoderToCache(cacheKey, encoder)
}
cachedEncoder.encodeInterface(val, stream)
}
@ -264,7 +320,7 @@ func (p prefix) addToEncoder(encoder Encoder, err error) (Encoder, error) {
return encoder, err
}
func decoderOfType(cfg *frozenConfig, typ reflect.Type) (Decoder, error) {
func decoderOfType(typ reflect.Type) (Decoder, error) {
typeName := typ.String()
typeDecoder := typeDecoders[typeName]
if typeDecoder != nil {
@ -277,19 +333,19 @@ func decoderOfType(cfg *frozenConfig, typ reflect.Type) (Decoder, error) {
}
}
cacheKey := typ
cachedDecoder := cfg.getDecoderFromCache(cacheKey)
cachedDecoder := getDecoderFromCache(cacheKey)
if cachedDecoder != nil {
return cachedDecoder, nil
}
placeholder := &placeholderDecoder{}
cfg.addDecoderToCache(cacheKey, placeholder)
newDecoder, err := createDecoderOfType(cfg, typ)
addDecoderToCache(cacheKey, placeholder)
newDecoder, err := createDecoderOfType(typ)
placeholder.valueDecoder = newDecoder
cfg.addDecoderToCache(cacheKey, newDecoder)
addDecoderToCache(cacheKey, newDecoder)
return newDecoder, err
}
func createDecoderOfType(cfg *frozenConfig, typ reflect.Type) (Decoder, error) {
func createDecoderOfType(typ reflect.Type) (Decoder, error) {
if typ.String() == "[]uint8" {
return &base64Codec{}, nil
}
@ -342,19 +398,19 @@ func createDecoderOfType(cfg *frozenConfig, typ reflect.Type) (Decoder, error) {
return &nonEmptyInterfaceCodec{}, nil
}
case reflect.Struct:
return prefix(fmt.Sprintf("[%s]", typ.String())).addToDecoder(decoderOfStruct(cfg, typ))
return prefix(fmt.Sprintf("[%s]", typ.String())).addToDecoder(decoderOfStruct(typ))
case reflect.Slice:
return prefix("[slice]").addToDecoder(decoderOfSlice(cfg, typ))
return prefix("[slice]").addToDecoder(decoderOfSlice(typ))
case reflect.Map:
return prefix("[map]").addToDecoder(decoderOfMap(cfg, typ))
return prefix("[map]").addToDecoder(decoderOfMap(typ))
case reflect.Ptr:
return prefix("[optional]").addToDecoder(decoderOfOptional(cfg, typ))
return prefix("[optional]").addToDecoder(decoderOfOptional(typ))
default:
return nil, fmt.Errorf("unsupported type: %v", typ)
}
}
func encoderOfType(cfg *frozenConfig, typ reflect.Type) (Encoder, error) {
func encoderOfType(typ reflect.Type) (Encoder, error) {
typeName := typ.String()
typeEncoder := typeEncoders[typeName]
if typeEncoder != nil {
@ -367,19 +423,19 @@ func encoderOfType(cfg *frozenConfig, typ reflect.Type) (Encoder, error) {
}
}
cacheKey := typ
cachedEncoder := cfg.getEncoderFromCache(cacheKey)
cachedEncoder := getEncoderFromCache(cacheKey)
if cachedEncoder != nil {
return cachedEncoder, nil
}
placeholder := &placeholderEncoder{}
cfg.addEncoderToCache(cacheKey, placeholder)
newEncoder, err := createEncoderOfType(cfg, typ)
addEncoderToCache(cacheKey, placeholder)
newEncoder, err := createEncoderOfType(typ)
placeholder.valueEncoder = newEncoder
cfg.addEncoderToCache(cacheKey, newEncoder)
addEncoderToCache(cacheKey, newEncoder)
return newEncoder, err
}
func createEncoderOfType(cfg *frozenConfig, typ reflect.Type) (Encoder, error) {
func createEncoderOfType(typ reflect.Type) (Encoder, error) {
if typ.String() == "[]uint8" {
return &base64Codec{}, nil
}
@ -433,42 +489,38 @@ func createEncoderOfType(cfg *frozenConfig, typ reflect.Type) (Encoder, error) {
return &nonEmptyInterfaceCodec{}, nil
}
case reflect.Struct:
return prefix(fmt.Sprintf("[%s]", typ.String())).addToEncoder(encoderOfStruct(cfg, typ))
return prefix(fmt.Sprintf("[%s]", typ.String())).addToEncoder(encoderOfStruct(typ))
case reflect.Slice:
return prefix("[slice]").addToEncoder(encoderOfSlice(cfg, typ))
return prefix("[slice]").addToEncoder(encoderOfSlice(typ))
case reflect.Map:
return prefix("[map]").addToEncoder(encoderOfMap(cfg, typ))
return prefix("[map]").addToEncoder(encoderOfMap(typ))
case reflect.Ptr:
return prefix("[optional]").addToEncoder(encoderOfOptional(cfg, typ))
return prefix("[optional]").addToEncoder(encoderOfOptional(typ))
default:
return nil, fmt.Errorf("unsupported type: %v", typ)
}
}
func decoderOfOptional(cfg *frozenConfig, typ reflect.Type) (Decoder, error) {
func decoderOfOptional(typ reflect.Type) (Decoder, error) {
elemType := typ.Elem()
decoder, err := decoderOfType(cfg, elemType)
decoder, err := decoderOfType(elemType)
if err != nil {
return nil, err
}
return &optionalDecoder{elemType, decoder}, nil
}
func encoderOfOptional(cfg *frozenConfig, typ reflect.Type) (Encoder, error) {
func encoderOfOptional(typ reflect.Type) (Encoder, error) {
elemType := typ.Elem()
elemEncoder, err := encoderOfType(cfg, elemType)
decoder, err := encoderOfType(elemType)
if err != nil {
return nil, err
}
encoder := &optionalEncoder{elemEncoder}
if elemType.Kind() == reflect.Map {
encoder = &optionalEncoder{encoder}
}
return encoder, nil
return &optionalEncoder{decoder}, nil
}
func decoderOfMap(cfg *frozenConfig, typ reflect.Type) (Decoder, error) {
decoder, err := decoderOfType(cfg, typ.Elem())
func decoderOfMap(typ reflect.Type) (Decoder, error) {
decoder, err := decoderOfType(typ.Elem())
if err != nil {
return nil, err
}
@ -480,16 +532,12 @@ func extractInterface(val interface{}) emptyInterface {
return *((*emptyInterface)(unsafe.Pointer(&val)))
}
func encoderOfMap(cfg *frozenConfig, typ reflect.Type) (Encoder, error) {
func encoderOfMap(typ reflect.Type) (Encoder, error) {
elemType := typ.Elem()
encoder, err := encoderOfType(cfg, elemType)
encoder, err := encoderOfType(elemType)
if err != nil {
return nil, err
}
mapInterface := reflect.New(typ).Elem().Interface()
if cfg.sortMapKeys {
return &sortKeysMapEncoder{typ, elemType, encoder, *((*emptyInterface)(unsafe.Pointer(&mapInterface)))}, nil
} else {
return &mapEncoder{typ, elemType, encoder, *((*emptyInterface)(unsafe.Pointer(&mapInterface)))}, nil
}
return &mapEncoder{typ, elemType, encoder, *((*emptyInterface)(unsafe.Pointer(&mapInterface)))}, nil
}

12
feature_reflect_array.go
View File

@ -7,16 +7,16 @@ import (
"unsafe"
)
func decoderOfSlice(cfg *frozenConfig, typ reflect.Type) (Decoder, error) {
decoder, err := decoderOfType(cfg, typ.Elem())
func decoderOfSlice(typ reflect.Type) (Decoder, error) {
decoder, err := decoderOfType(typ.Elem())
if err != nil {
return nil, err
}
return &sliceDecoder{typ, typ.Elem(), decoder}, nil
}
func encoderOfSlice(cfg *frozenConfig, typ reflect.Type) (Encoder, error) {
encoder, err := encoderOfType(cfg, typ.Elem())
func encoderOfSlice(typ reflect.Type) (Encoder, error) {
encoder, err := encoderOfType(typ.Elem())
if err != nil {
return nil, err
}
@ -34,10 +34,6 @@ type sliceEncoder struct {
func (encoder *sliceEncoder) encode(ptr unsafe.Pointer, stream *Stream) {
slice := (*sliceHeader)(ptr)
if slice.Data == nil {
stream.WriteNil()
return
}
if slice.Len == 0 {
stream.WriteEmptyArray()
return

79
feature_reflect_map.go
View File

@ -6,7 +6,6 @@ import (
"reflect"
"strconv"
"unsafe"
"sort"
)
type mapDecoder struct {
@ -137,81 +136,3 @@ func (encoder *mapEncoder) isEmpty(ptr unsafe.Pointer) bool {
realVal := reflect.ValueOf(*realInterface)
return realVal.Len() == 0
}
type sortKeysMapEncoder struct {
mapType reflect.Type
elemType reflect.Type
elemEncoder Encoder
mapInterface emptyInterface
}
func (encoder *sortKeysMapEncoder) encode(ptr unsafe.Pointer, stream *Stream) {
mapInterface := encoder.mapInterface
mapInterface.word = ptr
realInterface := (*interface{})(unsafe.Pointer(&mapInterface))
realVal := reflect.ValueOf(*realInterface)
// Extract and sort the keys.
keys := realVal.MapKeys()
sv := make([]reflectWithString, len(keys))
for i, v := range keys {
sv[i].v = v
if err := sv[i].resolve(); err != nil {
stream.Error = err
return
}
}
sort.Slice(sv, func(i, j int) bool { return sv[i].s < sv[j].s })
stream.WriteObjectStart()
for i, key := range sv {
if i != 0 {
stream.WriteMore()
}
encodeMapKey(key.v, stream)
stream.writeByte(':')
val := realVal.MapIndex(key.v).Interface()
encoder.elemEncoder.encodeInterface(val, stream)
}
stream.WriteObjectEnd()
}
type reflectWithString struct {
v reflect.Value
s string
}
func (w *reflectWithString) resolve() error {
if w.v.Kind() == reflect.String {
w.s = w.v.String()
return nil
}
if tm, ok := w.v.Interface().(encoding.TextMarshaler); ok {
buf, err := tm.MarshalText()
w.s = string(buf)
return err
}
switch w.v.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
w.s = strconv.FormatInt(w.v.Int(), 10)
return nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
w.s = strconv.FormatUint(w.v.Uint(), 10)
return nil
}
panic("unexpected map key type")
}
func (encoder *sortKeysMapEncoder) encodeInterface(val interface{}, stream *Stream) {
writeToStream(val, stream, encoder)
}
func (encoder *sortKeysMapEncoder) isEmpty(ptr unsafe.Pointer) bool {
mapInterface := encoder.mapInterface
mapInterface.word = ptr
realInterface := (*interface{})(unsafe.Pointer(&mapInterface))
realVal := reflect.ValueOf(*realInterface)
return realVal.Len() == 0
}

32
feature_reflect_object.go
View File

@ -9,7 +9,7 @@ import (
"unsafe"
)
func encoderOfStruct(cfg *frozenConfig, typ reflect.Type) (Encoder, error) {
func encoderOfStruct(typ reflect.Type) (Encoder, error) {
structEncoder_ := &structEncoder{}
fields := map[string]*structFieldEncoder{}
for _, field := range listStructFields(typ) {
@ -24,15 +24,6 @@ func encoderOfStruct(cfg *frozenConfig, typ reflect.Type) (Encoder, error) {
fieldEncoders[fieldEncoderKey] = &funcEncoder{fun}
}
}
for _, extension := range cfg.extensions {
alternativeFieldNames, fun, _ := extension(typ, field)
if alternativeFieldNames != nil {
extensionProvidedFieldNames = alternativeFieldNames
}
if fun != nil {
fieldEncoders[fieldEncoderKey] = &funcEncoder{fun}
}
}
tagParts := strings.Split(field.Tag.Get("json"), ",")
// if fieldNames set by extension, use theirs, otherwise try tags
fieldNames := calcFieldNames(field.Name, tagParts[0], extensionProvidedFieldNames)
@ -45,7 +36,7 @@ func encoderOfStruct(cfg *frozenConfig, typ reflect.Type) (Encoder, error) {
encoder := fieldEncoders[fieldEncoderKey]
var err error
if encoder == nil && len(fieldNames) > 0 {
encoder, err = encoderOfType(cfg, field.Type)
encoder, err = encoderOfType(field.Type)
if err != nil {
return prefix(fmt.Sprintf("{%s}", field.Name)).addToEncoder(encoder, err)
}
@ -80,7 +71,7 @@ func listStructFields(typ reflect.Type) []*reflect.StructField {
return fields
}
func decoderOfStruct(cfg *frozenConfig, typ reflect.Type) (Decoder, error) {
func decoderOfStruct(typ reflect.Type) (Decoder, error) {
fields := map[string]*structFieldDecoder{}
for i := 0; i < typ.NumField(); i++ {
field := typ.Field(i)
@ -95,21 +86,12 @@ func decoderOfStruct(cfg *frozenConfig, typ reflect.Type) (Decoder, error) {
fieldDecoders[fieldDecoderKey] = &funcDecoder{fun}
}
}
for _, extension := range cfg.extensions {
alternativeFieldNames, _, fun := extension(typ, &field)
if alternativeFieldNames != nil {
extensionProviedFieldNames = alternativeFieldNames
}
if fun != nil {
fieldDecoders[fieldDecoderKey] = &funcDecoder{fun}
}
}
decoder := fieldDecoders[fieldDecoderKey]
tagParts := strings.Split(field.Tag.Get("json"), ",")
fieldNames := calcFieldNames(field.Name, tagParts[0], extensionProviedFieldNames)
if decoder == nil && len(fieldNames) > 0 {
var err error
decoder, err = decoderOfType(cfg, field.Type)
decoder, err = decoderOfType(field.Type)
if err != nil {
return prefix(fmt.Sprintf("{%s}", field.Name)).addToDecoder(decoder, err)
}
@ -148,6 +130,12 @@ func calcFieldNames(originalFieldName string, tagProvidedFieldName string, exten
return fieldNames
}
func EnableUnexportedStructFieldsSupport() {
RegisterExtension(func(type_ reflect.Type, field *reflect.StructField) ([]string, EncoderFunc, DecoderFunc) {
return []string{field.Name}, nil, nil
})
}
func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder) (Decoder, error) {
knownHash := map[int32]struct{}{
0: {},

93
feature_stream.go
View File

@ -5,23 +5,16 @@ import (
)
type Stream struct {
cfg *frozenConfig
out io.Writer
buf []byte
n int
Error error
indention int
out io.Writer
buf []byte
n int
Error error
indention int
IndentionStep int
}
func NewStream(cfg *frozenConfig, out io.Writer, bufSize int) *Stream {
return &Stream{
cfg: cfg,
out: out,
buf: make([]byte, bufSize),
n: 0,
Error: nil,
indention: 0,
}
func NewStream(out io.Writer, bufSize int) *Stream {
return &Stream{out, make([]byte, bufSize), 0, nil, 0, 0}
}
func (b *Stream) Reset(out io.Writer) {
@ -197,6 +190,64 @@ func (b *Stream) WriteRaw(s string) {
b.n += n
}
func (stream *Stream) WriteString(s string) {
stream.ensure(32)
valLen := len(s)
toWriteLen := valLen
bufLengthMinusTwo := len(stream.buf) - 2 // make room for the quotes
if stream.n+toWriteLen > bufLengthMinusTwo {
toWriteLen = bufLengthMinusTwo - stream.n
}
n := stream.n
stream.buf[n] = '"'
n++
// write string, the fast path, without utf8 and escape support
i := 0
for ; i < toWriteLen; i++ {
c := s[i]
if c > 31 && c != '"' && c != '\\' {
stream.buf[n] = c
n++
} else {
break
}
}
if i == valLen {
stream.buf[n] = '"'
n++
stream.n = n
return
}
stream.n = n
// for the remaining parts, we process them char by char
stream.writeStringSlowPath(s, i, valLen)
stream.writeByte('"')
}
func (stream *Stream) writeStringSlowPath(s string, i int, valLen int) {
for ; i < valLen; i++ {
c := s[i]
switch c {
case '"':
stream.writeTwoBytes('\\', '"')
case '\\':
stream.writeTwoBytes('\\', '\\')
case '\b':
stream.writeTwoBytes('\\', 'b')
case '\f':
stream.writeTwoBytes('\\', 'f')
case '\n':
stream.writeTwoBytes('\\', 'n')
case '\r':
stream.writeTwoBytes('\\', 'r')
case '\t':
stream.writeTwoBytes('\\', 't')
default:
stream.writeByte(c)
}
}
}
func (stream *Stream) WriteNil() {
stream.writeFourBytes('n', 'u', 'l', 'l')
}
@ -218,7 +269,7 @@ func (stream *Stream) WriteBool(val bool) {
}
func (stream *Stream) WriteObjectStart() {
stream.indention += stream.cfg.indentionStep
stream.indention += stream.IndentionStep
stream.writeByte('{')
stream.writeIndention(0)
}
@ -229,8 +280,8 @@ func (stream *Stream) WriteObjectField(field string) {
}
func (stream *Stream) WriteObjectEnd() {
stream.writeIndention(stream.cfg.indentionStep)
stream.indention -= stream.cfg.indentionStep
stream.writeIndention(stream.IndentionStep)
stream.indention -= stream.IndentionStep
stream.writeByte('}')
}
@ -245,7 +296,7 @@ func (stream *Stream) WriteMore() {
}
func (stream *Stream) WriteArrayStart() {
stream.indention += stream.cfg.indentionStep
stream.indention += stream.IndentionStep
stream.writeByte('[')
stream.writeIndention(0)
}
@ -256,8 +307,8 @@ func (stream *Stream) WriteEmptyArray() {
}
func (stream *Stream) WriteArrayEnd() {
stream.writeIndention(stream.cfg.indentionStep)
stream.indention -= stream.cfg.indentionStep
stream.writeIndention(stream.IndentionStep)
stream.indention -= stream.IndentionStep
stream.writeByte(']')
}

23
feature_stream_float.go
View File

@ -2,12 +2,13 @@ package jsoniter
import (
"strconv"
"unsafe"
)
var _POW10 []uint64
var POW10 []uint64
func init() {
_POW10 = []uint64{1, 10, 100, 1000, 10000, 100000, 1000000}
POW10 = []uint64{1, 10, 100, 1000, 10000, 100000, 1000000}
}
func (stream *Stream) WriteFloat32(val float32) {
@ -33,7 +34,7 @@ func (stream *Stream) WriteFloat32Lossy(val float32) {
}
stream.writeByte('.')
stream.ensure(10)
for p := precision - 1; p > 0 && fval < _POW10[p]; p-- {
for p := precision - 1; p > 0 && fval < POW10[p]; p-- {
stream.writeByte('0')
}
stream.WriteUint64(fval)
@ -65,7 +66,7 @@ func (stream *Stream) WriteFloat64Lossy(val float64) {
}
stream.writeByte('.')
stream.ensure(10)
for p := precision - 1; p > 0 && fval < _POW10[p]; p-- {
for p := precision - 1; p > 0 && fval < POW10[p]; p-- {
stream.writeByte('0')
}
stream.WriteUint64(fval)
@ -73,3 +74,17 @@ func (stream *Stream) WriteFloat64Lossy(val float64) {
stream.n--
}
}
// EnableLossyFloatMarshalling keeps 10**(-6) precision
// for float variables for better performance.
func EnableLossyFloatMarshalling() {
// for better performance
RegisterTypeEncoder("float32", func(ptr unsafe.Pointer, stream *Stream) {
val := *((*float32)(ptr))
stream.WriteFloat32Lossy(val)
})
RegisterTypeEncoder("float64", func(ptr unsafe.Pointer, stream *Stream) {
val := *((*float64)(ptr))
stream.WriteFloat64Lossy(val)
})
}

144
feature_stream_int.go
View File

@ -1,15 +1,15 @@
package jsoniter
var _DIGITS []uint32
var DIGITS []uint32
func init() {
_DIGITS = make([]uint32, 1000)
DIGITS = make([]uint32, 1000)
for i := uint32(0); i < 1000; i++ {
_DIGITS[i] = (((i / 100) + '0') << 16) + ((((i / 10) % 10) + '0') << 8) + i%10 + '0'
DIGITS[i] = (((i / 100) + '0') << 16) + ((((i / 10) % 10) + '0') << 8) + i%10 + '0'
if i < 10 {
_DIGITS[i] += 2 << 24
DIGITS[i] += 2 << 24
} else if i < 100 {
_DIGITS[i] += 1 << 24
DIGITS[i] += 1 << 24
}
}
}
@ -38,7 +38,7 @@ func writeBuf(buf []byte, v uint32, n int) {
func (stream *Stream) WriteUint8(val uint8) {
stream.ensure(3)
stream.n = writeFirstBuf(stream.buf, _DIGITS[val], stream.n)
stream.n = writeFirstBuf(stream.buf, DIGITS[val], stream.n)
}
func (stream *Stream) WriteInt8(nval int8) {
@ -52,19 +52,19 @@ func (stream *Stream) WriteInt8(nval int8) {
} else {
val = uint8(nval)
}
stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
stream.n = writeFirstBuf(stream.buf, DIGITS[val], n)
}
func (stream *Stream) WriteUint16(val uint16) {
stream.ensure(5)
q1 := val / 1000
if q1 == 0 {
stream.n = writeFirstBuf(stream.buf, _DIGITS[val], stream.n)
stream.n = writeFirstBuf(stream.buf, DIGITS[val], stream.n)
return
}
r1 := val - q1*1000
n := writeFirstBuf(stream.buf, _DIGITS[q1], stream.n)
writeBuf(stream.buf, _DIGITS[r1], n)
n := writeFirstBuf(stream.buf, DIGITS[q1], stream.n)
writeBuf(stream.buf, DIGITS[r1], n)
stream.n = n + 3
return
}
@ -82,12 +82,12 @@ func (stream *Stream) WriteInt16(nval int16) {
}
q1 := val / 1000
if q1 == 0 {
stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
stream.n = writeFirstBuf(stream.buf, DIGITS[val], n)
return
}
r1 := val - q1*1000
n = writeFirstBuf(stream.buf, _DIGITS[q1], n)
writeBuf(stream.buf, _DIGITS[r1], n)
n = writeFirstBuf(stream.buf, DIGITS[q1], n)
writeBuf(stream.buf, DIGITS[r1], n)
stream.n = n + 3
return
}
@ -97,30 +97,30 @@ func (stream *Stream) WriteUint32(val uint32) {
n := stream.n
q1 := val / 1000
if q1 == 0 {
stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
stream.n = writeFirstBuf(stream.buf, DIGITS[val], n)
return
}
r1 := val - q1*1000
q2 := q1 / 1000
if q2 == 0 {
n := writeFirstBuf(stream.buf, _DIGITS[q1], n)
writeBuf(stream.buf, _DIGITS[r1], n)
n := writeFirstBuf(stream.buf, DIGITS[q1], n)
writeBuf(stream.buf, DIGITS[r1], n)
stream.n = n + 3
return
}
r2 := q1 - q2*1000
q3 := q2 / 1000
if q3 == 0 {
n = writeFirstBuf(stream.buf, _DIGITS[q2], n)
n = writeFirstBuf(stream.buf, DIGITS[q2], n)
} else {
r3 := q2 - q3*1000
stream.buf[n] = byte(q3 + '0')
n++
writeBuf(stream.buf, _DIGITS[r3], n)
writeBuf(stream.buf, DIGITS[r3], n)
n += 3
}
writeBuf(stream.buf, _DIGITS[r2], n)
writeBuf(stream.buf, _DIGITS[r1], n+3)
writeBuf(stream.buf, DIGITS[r2], n)
writeBuf(stream.buf, DIGITS[r1], n+3)
stream.n = n + 6
}
@ -137,30 +137,30 @@ func (stream *Stream) WriteInt32(nval int32) {
}
q1 := val / 1000
if q1 == 0 {
stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
stream.n = writeFirstBuf(stream.buf, DIGITS[val], n)
return
}
r1 := val - q1*1000
q2 := q1 / 1000
if q2 == 0 {
n := writeFirstBuf(stream.buf, _DIGITS[q1], n)
writeBuf(stream.buf, _DIGITS[r1], n)
n := writeFirstBuf(stream.buf, DIGITS[q1], n)
writeBuf(stream.buf, DIGITS[r1], n)
stream.n = n + 3
return
}
r2 := q1 - q2*1000
q3 := q2 / 1000
if q3 == 0 {
n = writeFirstBuf(stream.buf, _DIGITS[q2], n)
n = writeFirstBuf(stream.buf, DIGITS[q2], n)
} else {
r3 := q2 - q3*1000
stream.buf[n] = byte(q3 + '0')
n++
writeBuf(stream.buf, _DIGITS[r3], n)
writeBuf(stream.buf, DIGITS[r3], n)
n += 3
}
writeBuf(stream.buf, _DIGITS[r2], n)
writeBuf(stream.buf, _DIGITS[r1], n+3)
writeBuf(stream.buf, DIGITS[r2], n)
writeBuf(stream.buf, DIGITS[r1], n+3)
stream.n = n + 6
}
@ -169,62 +169,62 @@ func (stream *Stream) WriteUint64(val uint64) {
n := stream.n
q1 := val / 1000
if q1 == 0 {
stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
stream.n = writeFirstBuf(stream.buf, DIGITS[val], n)
return
}
r1 := val - q1*1000
q2 := q1 / 1000
if q2 == 0 {
n := writeFirstBuf(stream.buf, _DIGITS[q1], n)
writeBuf(stream.buf, _DIGITS[r1], n)
n := writeFirstBuf(stream.buf, DIGITS[q1], n)
writeBuf(stream.buf, DIGITS[r1], n)
stream.n = n + 3
return
}
r2 := q1 - q2*1000
q3 := q2 / 1000
if q3 == 0 {
n = writeFirstBuf(stream.buf, _DIGITS[q2], n)
writeBuf(stream.buf, _DIGITS[r2], n)
writeBuf(stream.buf, _DIGITS[r1], n+3)
n = writeFirstBuf(stream.buf, DIGITS[q2], n)
writeBuf(stream.buf, DIGITS[r2], n)
writeBuf(stream.buf, DIGITS[r1], n+3)
stream.n = n + 6
return
}
r3 := q2 - q3*1000
q4 := q3 / 1000
if q4 == 0 {
n = writeFirstBuf(stream.buf, _DIGITS[q3], n)
writeBuf(stream.buf, _DIGITS[r3], n)
writeBuf(stream.buf, _DIGITS[r2], n+3)
writeBuf(stream.buf, _DIGITS[r1], n+6)
n = writeFirstBuf(stream.buf, DIGITS[q3], n)
writeBuf(stream.buf, DIGITS[r3], n)
writeBuf(stream.buf, DIGITS[r2], n+3)
writeBuf(stream.buf, DIGITS[r1], n+6)
stream.n = n + 9
return
}
r4 := q3 - q4*1000
q5 := q4 / 1000
if q5 == 0 {
n = writeFirstBuf(stream.buf, _DIGITS[q4], n)
writeBuf(stream.buf, _DIGITS[r4], n)
writeBuf(stream.buf, _DIGITS[r3], n+3)
writeBuf(stream.buf, _DIGITS[r2], n+6)
writeBuf(stream.buf, _DIGITS[r1], n+9)
n = writeFirstBuf(stream.buf, DIGITS[q4], n)
writeBuf(stream.buf, DIGITS[r4], n)
writeBuf(stream.buf, DIGITS[r3], n+3)
writeBuf(stream.buf, DIGITS[r2], n+6)
writeBuf(stream.buf, DIGITS[r1], n+9)
stream.n = n + 12
return
}
r5 := q4 - q5*1000
q6 := q5 / 1000
if q6 == 0 {
n = writeFirstBuf(stream.buf, _DIGITS[q5], n)
n = writeFirstBuf(stream.buf, DIGITS[q5], n)
} else {
n = writeFirstBuf(stream.buf, _DIGITS[q6], n)
n = writeFirstBuf(stream.buf, DIGITS[q6], n)
r6 := q5 - q6*1000
writeBuf(stream.buf, _DIGITS[r6], n)
writeBuf(stream.buf, DIGITS[r6], n)
n += 3
}
writeBuf(stream.buf, _DIGITS[r5], n)
writeBuf(stream.buf, _DIGITS[r4], n+3)
writeBuf(stream.buf, _DIGITS[r3], n+6)
writeBuf(stream.buf, _DIGITS[r2], n+9)
writeBuf(stream.buf, _DIGITS[r1], n+12)
writeBuf(stream.buf, DIGITS[r5], n)
writeBuf(stream.buf, DIGITS[r4], n+3)
writeBuf(stream.buf, DIGITS[r3], n+6)
writeBuf(stream.buf, DIGITS[r2], n+9)
writeBuf(stream.buf, DIGITS[r1], n+12)
stream.n = n + 15
}
@ -241,63 +241,63 @@ func (stream *Stream) WriteInt64(nval int64) {
}
q1 := val / 1000
if q1 == 0 {
stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
stream.n = writeFirstBuf(stream.buf, DIGITS[val], n)
return
}
r1 := val - q1*1000
q2 := q1 / 1000
if q2 == 0 {
n := writeFirstBuf(stream.buf, _DIGITS[q1], n)
writeBuf(stream.buf, _DIGITS[r1], n)
n := writeFirstBuf(stream.buf, DIGITS[q1], n)
writeBuf(stream.buf, DIGITS[r1], n)
stream.n = n + 3
return
}
r2 := q1 - q2*1000
q3 := q2 / 1000
if q3 == 0 {
n = writeFirstBuf(stream.buf, _DIGITS[q2], n)
writeBuf(stream.buf, _DIGITS[r2], n)
writeBuf(stream.buf, _DIGITS[r1], n+3)
n = writeFirstBuf(stream.buf, DIGITS[q2], n)
writeBuf(stream.buf, DIGITS[r2], n)
writeBuf(stream.buf, DIGITS[r1], n+3)
stream.n = n + 6
return
}
r3 := q2 - q3*1000
q4 := q3 / 1000
if q4 == 0 {
n = writeFirstBuf(stream.buf, _DIGITS[q3], n)
writeBuf(stream.buf, _DIGITS[r3], n)
writeBuf(stream.buf, _DIGITS[r2], n+3)
writeBuf(stream.buf, _DIGITS[r1], n+6)
n = writeFirstBuf(stream.buf, DIGITS[q3], n)
writeBuf(stream.buf, DIGITS[r3], n)
writeBuf(stream.buf, DIGITS[r2], n+3)
writeBuf(stream.buf, DIGITS[r1], n+6)
stream.n = n + 9
return
}
r4 := q3 - q4*1000
q5 := q4 / 1000
if q5 == 0 {
n = writeFirstBuf(stream.buf, _DIGITS[q4], n)
writeBuf(stream.buf, _DIGITS[r4], n)
writeBuf(stream.buf, _DIGITS[r3], n+3)
writeBuf(stream.buf, _DIGITS[r2], n+6)
writeBuf(stream.buf, _DIGITS[r1], n+9)
n = writeFirstBuf(stream.buf, DIGITS[q4], n)
writeBuf(stream.buf, DIGITS[r4], n)
writeBuf(stream.buf, DIGITS[r3], n+3)
writeBuf(stream.buf, DIGITS[r2], n+6)
writeBuf(stream.buf, DIGITS[r1], n+9)
stream.n = n + 12
return
}
r5 := q4 - q5*1000
q6 := q5 / 1000
if q6 == 0 {
n = writeFirstBuf(stream.buf, _DIGITS[q5], n)
n = writeFirstBuf(stream.buf, DIGITS[q5], n)
} else {
stream.buf[n] = byte(q6 + '0')
n++
r6 := q5 - q6*1000
writeBuf(stream.buf, _DIGITS[r6], n)
writeBuf(stream.buf, DIGITS[r6], n)
n += 3
}
writeBuf(stream.buf, _DIGITS[r5], n)
writeBuf(stream.buf, _DIGITS[r4], n+3)
writeBuf(stream.buf, _DIGITS[r3], n+6)
writeBuf(stream.buf, _DIGITS[r2], n+9)
writeBuf(stream.buf, _DIGITS[r1], n+12)
writeBuf(stream.buf, DIGITS[r5], n)
writeBuf(stream.buf, DIGITS[r4], n+3)
writeBuf(stream.buf, DIGITS[r3], n+6)
writeBuf(stream.buf, DIGITS[r2], n+9)
writeBuf(stream.buf, DIGITS[r1], n+12)
stream.n = n + 15
}

351
feature_stream_string.go
View File

@ -1,351 +0,0 @@
package jsoniter
import (
"unicode/utf8"
)
// htmlSafeSet holds the value true if the ASCII character with the given
// array position can be safely represented inside a JSON string, embedded
// inside of HTML <script> tags, without any additional escaping.
//
// All values are true except for the ASCII control characters (0-31), the
// double quote ("), the backslash character ("\"), HTML opening and closing
// tags ("<" and ">"), and the ampersand ("&").
var htmlSafeSet = [utf8.RuneSelf]bool{
' ': true,
'!': true,
'"': false,
'#': true,
'$': true,
'%': true,
'&': false,
'\'': true,
'(': true,
')': true,
'*': true,
'+': true,
',': true,
'-': true,
'.': true,
'/': true,
'0': true,
'1': true,
'2': true,
'3': true,
'4': true,
'5': true,
'6': true,
'7': true,
'8': true,
'9': true,
':': true,
';': true,
'<': false,
'=': true,
'>': false,
'?': true,
'@': true,
'A': true,
'B': true,
'C': true,
'D': true,
'E': true,
'F': true,
'G': true,
'H': true,
'I': true,
'J': true,
'K': true,
'L': true,
'M': true,
'N': true,
'O': true,
'P': true,
'Q': true,
'R': true,
'S': true,
'T': true,
'U': true,
'V': true,
'W': true,
'X': true,
'Y': true,
'Z': true,
'[': true,
'\\': false,
']': true,
'^': true,
'_': true,
'`': true,
'a': true,
'b': true,
'c': true,
'd': true,
'e': true,
'f': true,
'g': true,
'h': true,
'i': true,
'j': true,
'k': true,
'l': true,
'm': true,
'n': true,
'o': true,
'p': true,
'q': true,
'r': true,
's': true,
't': true,
'u': true,
'v': true,
'w': true,
'x': true,
'y': true,
'z': true,
'{': true,
'|': true,
'}': true,
'~': true,
'\u007f': true,
}
// safeSet holds the value true if the ASCII character with the given array
// position can be represented inside a JSON string without any further
// escaping.
//
// All values are true except for the ASCII control characters (0-31), the
// double quote ("), and the backslash character ("\").
var safeSet = [utf8.RuneSelf]bool{
' ': true,
'!': true,
'"': false,
'#': true,
'$': true,
'%': true,
'&': true,
'\'': true,
'(': true,
')': true,
'*': true,
'+': true,
',': true,
'-': true,
'.': true,
'/': true,
'0': true,
'1': true,
'2': true,
'3': true,
'4': true,
'5': true,
'6': true,
'7': true,
'8': true,
'9': true,
':': true,
';': true,
'<': true,
'=': true,
'>': true,
'?': true,
'@': true,
'A': true,
'B': true,
'C': true,
'D': true,
'E': true,
'F': true,
'G': true,
'H': true,
'I': true,
'J': true,
'K': true,
'L': true,
'M': true,
'N': true,
'O': true,
'P': true,
'Q': true,
'R': true,
'S': true,
'T': true,
'U': true,
'V': true,
'W': true,
'X': true,
'Y': true,
'Z': true,
'[': true,
'\\': false,
']': true,
'^': true,
'_': true,
'`': true,
'a': true,
'b': true,
'c': true,
'd': true,
'e': true,
'f': true,
'g': true,
'h': true,
'i': true,
'j': true,
'k': true,
'l': true,
'm': true,
'n': true,
'o': true,
'p': true,
'q': true,
'r': true,
's': true,
't': true,
'u': true,
'v': true,
'w': true,
'x': true,
'y': true,
'z': true,
'{': true,
'|': true,
'}': true,
'~': true,
'\u007f': true,
}
var hex = "0123456789abcdef"
func (stream *Stream) WriteStringWithHtmlEscaped(s string) {
stream.ensure(32)
valLen := len(s)
toWriteLen := valLen
bufLengthMinusTwo := len(stream.buf) - 2 // make room for the quotes
if stream.n+toWriteLen > bufLengthMinusTwo {
toWriteLen = bufLengthMinusTwo - stream.n
}
n := stream.n
stream.buf[n] = '"'
n++
// write string, the fast path, without utf8 and escape support
i := 0
for ; i < toWriteLen; i++ {
c := s[i]
if c <= utf8.RuneSelf && htmlSafeSet[c] {
stream.buf[n] = c
n++
} else {
break
}
}
if i == valLen {
stream.buf[n] = '"'
n++
stream.n = n
return
}
stream.n = n
writeStringSlowPath(stream, htmlSafeSet, i, s, valLen)
}
func (stream *Stream) WriteString(s string) {
stream.ensure(32)
valLen := len(s)
toWriteLen := valLen
bufLengthMinusTwo := len(stream.buf) - 2 // make room for the quotes
if stream.n+toWriteLen > bufLengthMinusTwo {
toWriteLen = bufLengthMinusTwo - stream.n
}
n := stream.n
stream.buf[n] = '"'
n++
// write string, the fast path, without utf8 and escape support
i := 0
for ; i < toWriteLen; i++ {
c := s[i]
if c > 31 && c != '"' && c != '\\' {
stream.buf[n] = c
n++
} else {
break
}
}
if i == valLen {
stream.buf[n] = '"'
n++
stream.n = n
return
}
stream.n = n
writeStringSlowPath(stream, safeSet, i, s, valLen)
}
func writeStringSlowPath(stream *Stream, safeSet [utf8.RuneSelf]bool, i int, s string, valLen int) {
start := i
// for the remaining parts, we process them char by char
for ; i < valLen; i++ {
if b := s[i]; b < utf8.RuneSelf {
if safeSet[b] {
i++
continue
}
if start < i {
stream.WriteRaw(s[start:i])
}
switch b {
case '\\', '"':
stream.writeTwoBytes('\\', b)
case '\n':
stream.writeTwoBytes('\\', 'n')
case '\r':
stream.writeTwoBytes('\\', 'r')
case '\t':
stream.writeTwoBytes('\\', 't')
default:
// This encodes bytes < 0x20 except for \t, \n and \r.
// If escapeHTML is set, it also escapes <, >, and &
// because they can lead to security holes when
// user-controlled strings are rendered into JSON
// and served to some browsers.
stream.WriteRaw(`\u00`)
stream.writeTwoBytes(hex[b>>4], hex[b&0xF])
}
i++
start = i
continue
}
c, size := utf8.DecodeRuneInString(s[i:])
if c == utf8.RuneError && size == 1 {
if start < i {
stream.WriteRaw(s[start:i])
}
stream.WriteRaw(`\ufffd`)
i += size
start = i
continue
}
// U+2028 is LINE SEPARATOR.
// U+2029 is PARAGRAPH SEPARATOR.
// They are both technically valid characters in JSON strings,
// but don't work in JSONP, which has to be evaluated as JavaScript,
// and can lead to security holes there. It is valid JSON to
// escape them, so we do so unconditionally.
// See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
if c == '\u2028' || c == '\u2029' {
if start < i {
stream.WriteRaw(s[start:i])
}
stream.WriteRaw(`\u202`)
stream.writeByte(hex[c&0xF])
i += size
start = i
continue
}
i += size
}
if start < len(s) {
stream.WriteRaw(s[start:])
}
stream.writeByte('"')
}

2
jsoniter_adapter_test.go
View File

@ -37,12 +37,10 @@ func Test_new_encoder(t *testing.T) {
should := require.New(t)
buf1 := &bytes.Buffer{}
encoder1 := json.NewEncoder(buf1)
encoder1.SetEscapeHTML(false)
encoder1.Encode([]int{1})
should.Equal("[1]\n", buf1.String())
buf2 := &bytes.Buffer{}
encoder2 := NewEncoder(buf2)
encoder2.SetEscapeHTML(false)
encoder2.Encode([]int{1})
should.Equal("[1]", buf2.String())
}

27
jsoniter_array_test.go
View File

@ -10,10 +10,10 @@ import (
func Test_empty_array(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `[]`)
iter := ParseString(`[]`)
cont := iter.ReadArray()
should.False(cont)
iter = ParseString(ConfigOfDefault, `[]`)
iter = ParseString(`[]`)
iter.ReadArrayCB(func(iter *Iterator) bool {
should.FailNow("should not call")
return true
@ -22,11 +22,11 @@ func Test_empty_array(t *testing.T) {
func Test_one_element(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `[1]`)
iter := ParseString(`[1]`)
should.True(iter.ReadArray())
should.Equal(1, iter.ReadInt())
should.False(iter.ReadArray())
iter = ParseString(ConfigOfDefault, `[1]`)
iter = ParseString(`[1]`)
iter.ReadArrayCB(func(iter *Iterator) bool {
should.Equal(1, iter.ReadInt())
return true
@ -35,13 +35,13 @@ func Test_one_element(t *testing.T) {
func Test_two_elements(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `[1,2]`)
iter := ParseString(`[1,2]`)
should.True(iter.ReadArray())
should.Equal(int64(1), iter.ReadInt64())
should.True(iter.ReadArray())
should.Equal(int64(2), iter.ReadInt64())
should.False(iter.ReadArray())
iter = ParseString(ConfigOfDefault, `[1,2]`)
iter = ParseString(`[1,2]`)
should.Equal([]interface{}{float64(1), float64(2)}, iter.Read())
}
@ -152,7 +152,7 @@ func Test_invalid_array(t *testing.T) {
}
func Test_whitespace_in_head(t *testing.T) {
iter := ParseString(ConfigOfDefault, ` [1]`)
iter := ParseString(` [1]`)
cont := iter.ReadArray()
if cont != true {
t.FailNow()
@ -163,7 +163,7 @@ func Test_whitespace_in_head(t *testing.T) {
}
func Test_whitespace_after_array_start(t *testing.T) {
iter := ParseString(ConfigOfDefault, `[ 1]`)
iter := ParseString(`[ 1]`)
cont := iter.ReadArray()
if cont != true {
t.FailNow()
@ -174,7 +174,7 @@ func Test_whitespace_after_array_start(t *testing.T) {
}
func Test_whitespace_before_array_end(t *testing.T) {
iter := ParseString(ConfigOfDefault, `[1 ]`)
iter := ParseString(`[1 ]`)
cont := iter.ReadArray()
if cont != true {
t.FailNow()
@ -189,7 +189,7 @@ func Test_whitespace_before_array_end(t *testing.T) {
}
func Test_whitespace_before_comma(t *testing.T) {
iter := ParseString(ConfigOfDefault, `[1 ,2]`)
iter := ParseString(`[1 ,2]`)
cont := iter.ReadArray()
if cont != true {
t.FailNow()
@ -213,7 +213,8 @@ func Test_whitespace_before_comma(t *testing.T) {
func Test_write_array(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(Config{IndentionStep: 2}.Froze(), buf, 4096)
stream := NewStream(buf, 4096)
stream.IndentionStep = 2
stream.WriteArrayStart()
stream.WriteInt(1)
stream.WriteMore()
@ -227,7 +228,7 @@ func Test_write_array(t *testing.T) {
func Test_write_val_array(t *testing.T) {
should := require.New(t)
val := []int{1, 2, 3}
str, err := MarshalToString(&val)
str, err := MarshalToString(val)
should.Nil(err)
should.Equal("[1,2,3]", str)
}
@ -287,7 +288,7 @@ func Test_decode_byte_array(t *testing.T) {
func Benchmark_jsoniter_array(b *testing.B) {
b.ReportAllocs()
input := []byte(`[1,2,3,4,5,6,7,8,9]`)
iter := ParseBytes(ConfigOfDefault, input)
iter := ParseBytes(input)
b.ResetTimer()
for n := 0; n < b.N; n++ {
iter.ResetBytes(input)

4
jsoniter_base64_test.go
View File

File diff suppressed because one or more lines are too long

10
jsoniter_bool_test.go
View File

@ -8,15 +8,15 @@ import (
func Test_true(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `true`)
iter := ParseString(`true`)
should.True(iter.ReadBool())
iter = ParseString(ConfigOfDefault, `true`)
iter = ParseString(`true`)
should.Equal(true, iter.Read())
}
func Test_false(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `false`)
iter := ParseString(`false`)
should.False(iter.ReadBool())
}
@ -30,7 +30,7 @@ func Test_read_bool_as_any(t *testing.T) {
func Test_write_true_false(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteTrue()
stream.WriteFalse()
stream.Flush()
@ -41,7 +41,7 @@ func Test_write_true_false(t *testing.T) {
func Test_write_val_bool(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteVal(true)
stream.Flush()
should.Nil(stream.Error)

23
jsoniter_customize_test.go
View File

@ -19,7 +19,7 @@ func Test_customize_type_decoder(t *testing.T) {
}
*((*time.Time)(ptr)) = t
})
defer ConfigOfDefault.CleanDecoders()
defer CleanDecoders()
val := time.Time{}
err := Unmarshal([]byte(`"2016-12-05 08:43:28"`), &val)
if err != nil {
@ -37,7 +37,7 @@ func Test_customize_type_encoder(t *testing.T) {
t := *((*time.Time)(ptr))
stream.WriteString(t.UTC().Format("2006-01-02 15:04:05"))
})
defer ConfigOfDefault.CleanEncoders()
defer CleanEncoders()
val := time.Unix(0, 0)
str, err := MarshalToString(val)
should.Nil(err)
@ -45,13 +45,13 @@ func Test_customize_type_encoder(t *testing.T) {
}
func Test_customize_byte_array_encoder(t *testing.T) {
ConfigOfDefault.CleanEncoders()
CleanEncoders()
should := require.New(t)
RegisterTypeEncoder("[]uint8", func(ptr unsafe.Pointer, stream *Stream) {
t := *((*[]byte)(ptr))
stream.WriteString(string(t))
})
defer ConfigOfDefault.CleanEncoders()
defer CleanEncoders()
val := []byte("abc")
str, err := MarshalToString(val)
should.Nil(err)
@ -60,8 +60,9 @@ func Test_customize_byte_array_encoder(t *testing.T) {
func Test_customize_float_marshal(t *testing.T) {
should := require.New(t)
json := Config{MarshalFloatWith6Digits: true}.Froze()
str, err := json.MarshalToString(float32(1.23456789))
EnableLossyFloatMarshalling()
defer CleanEncoders()
str, err := MarshalToString(float32(1.23456789))
should.Nil(err)
should.Equal("1.234568", str)
}
@ -74,7 +75,7 @@ func Test_customize_field_decoder(t *testing.T) {
RegisterFieldDecoder("jsoniter.Tom", "field1", func(ptr unsafe.Pointer, iter *Iterator) {
*((*string)(ptr)) = strconv.Itoa(iter.ReadInt())
})
defer ConfigOfDefault.CleanDecoders()
defer CleanDecoders()
tom := Tom{}
err := Unmarshal([]byte(`{"field1": 100}`), &tom)
if err != nil {
@ -112,7 +113,7 @@ func Test_customize_field_by_extension(t *testing.T) {
}
func Test_unexported_fields(t *testing.T) {
jsoniter := Config{SupportUnexportedStructFields: true}.Froze()
EnableUnexportedStructFieldsSupport()
should := require.New(t)
type TestObject struct {
field1 string
@ -120,12 +121,12 @@ func Test_unexported_fields(t *testing.T) {
}
obj := TestObject{}
obj.field1 = "hello"
should.Nil(jsoniter.UnmarshalFromString(`{}`, &obj))
should.Nil(UnmarshalFromString(`{}`, &obj))
should.Equal("hello", obj.field1)
should.Nil(jsoniter.UnmarshalFromString(`{"field1": "world", "field-2": "abc"}`, &obj))
should.Nil(UnmarshalFromString(`{"field1": "world", "field-2": "abc"}`, &obj))
should.Equal("world", obj.field1)
should.Equal("abc", obj.field2)
str, err := jsoniter.MarshalToString(obj)
str, err := MarshalToString(obj)
should.Nil(err)
should.Contains(str, `"field-2":"abc"`)
}

2
jsoniter_demo_test.go
View File

@ -16,7 +16,7 @@ func Test_bind_api_demo(t *testing.T) {
}
func Test_iterator_api_demo(t *testing.T) {
iter := ParseString(ConfigOfDefault, `[0,1,2,3]`)
iter := ParseString(`[0,1,2,3]`)
total := 0
for iter.ReadArray() {
total += iter.ReadInt()

38
jsoniter_find_end_test.go
View File

@ -7,56 +7,56 @@ import (
)
func Test_string_end(t *testing.T) {
end, escaped := ParseString(ConfigOfDefault, `abc"`).findStringEnd()
end, escaped := ParseString(`abc"`).findStringEnd()
if end != 4 {
t.Fatal(end)
}
if escaped != false {
t.Fatal(escaped)
}
end, escaped = ParseString(ConfigOfDefault, `abc\\"`).findStringEnd()
end, escaped = ParseString(`abc\\"`).findStringEnd()
if end != 6 {
t.Fatal(end)
}
if escaped != true {
t.Fatal(escaped)
}
end, escaped = ParseString(ConfigOfDefault, `abc\\\\"`).findStringEnd()
end, escaped = ParseString(`abc\\\\"`).findStringEnd()
if end != 8 {
t.Fatal(end)
}
if escaped != true {
t.Fatal(escaped)
}
end, escaped = ParseString(ConfigOfDefault, `abc\"`).findStringEnd()
end, escaped = ParseString(`abc\"`).findStringEnd()
if end != -1 {
t.Fatal(end)
}
if escaped != false {
t.Fatal(escaped)
}
end, escaped = ParseString(ConfigOfDefault, `abc\`).findStringEnd()
end, escaped = ParseString(`abc\`).findStringEnd()
if end != -1 {
t.Fatal(end)
}
if escaped != true {
t.Fatal(escaped)
}
end, escaped = ParseString(ConfigOfDefault, `abc\\`).findStringEnd()
end, escaped = ParseString(`abc\\`).findStringEnd()
if end != -1 {
t.Fatal(end)
}
if escaped != false {
t.Fatal(escaped)
}
end, escaped = ParseString(ConfigOfDefault, `\\`).findStringEnd()
end, escaped = ParseString(`\\`).findStringEnd()
if end != -1 {
t.Fatal(end)
}
if escaped != false {
t.Fatal(escaped)
}
end, escaped = ParseString(ConfigOfDefault, `\`).findStringEnd()
end, escaped = ParseString(`\`).findStringEnd()
if end != -1 {
t.Fatal(end)
}
@ -91,54 +91,54 @@ func (reader *StagedReader) Read(p []byte) (n int, err error) {
func Test_skip_string(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `"abc`)
iter := ParseString(`"abc`)
iter.skipString()
should.Equal(1, iter.head)
iter = ParseString(ConfigOfDefault, `\""abc`)
iter = ParseString(`\""abc`)
iter.skipString()
should.Equal(3, iter.head)
reader := &StagedReader{
r1: `abc`,
r2: `"`,
}
iter = Parse(ConfigOfDefault, reader, 4096)
iter = Parse(reader, 4096)
iter.skipString()
should.Equal(1, iter.head)
reader = &StagedReader{
r1: `abc`,
r2: `1"`,
}
iter = Parse(ConfigOfDefault, reader, 4096)
iter = Parse(reader, 4096)
iter.skipString()
should.Equal(2, iter.head)
reader = &StagedReader{
r1: `abc\`,
r2: `"`,
}
iter = Parse(ConfigOfDefault, reader, 4096)
iter = Parse(reader, 4096)
iter.skipString()
should.NotNil(iter.Error)
reader = &StagedReader{
r1: `abc\`,
r2: `""`,
}
iter = Parse(ConfigOfDefault, reader, 4096)
iter = Parse(reader, 4096)
iter.skipString()
should.Equal(2, iter.head)
}
func Test_skip_object(t *testing.T) {
iter := ParseString(ConfigOfDefault, `}`)
iter := ParseString(`}`)
iter.skipObject()
if iter.head != 1 {
t.Fatal(iter.head)
}
iter = ParseString(ConfigOfDefault, `a}`)
iter = ParseString(`a}`)
iter.skipObject()
if iter.head != 2 {
t.Fatal(iter.head)
}
iter = ParseString(ConfigOfDefault, `{}}a`)
iter = ParseString(`{}}a`)
iter.skipObject()
if iter.head != 3 {
t.Fatal(iter.head)
@ -147,12 +147,12 @@ func Test_skip_object(t *testing.T) {
r1: `{`,
r2: `}}a`,
}
iter = Parse(ConfigOfDefault, reader, 4096)
iter = Parse(reader, 4096)
iter.skipObject()
if iter.head != 2 {
t.Fatal(iter.head)
}
iter = ParseString(ConfigOfDefault, `"}"}a`)
iter = ParseString(`"}"}a`)
iter.skipObject()
if iter.head != 4 {
t.Fatal(iter.head)

30
jsoniter_float_test.go
View File

@ -11,7 +11,7 @@ import (
func Test_read_big_float(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `12.3`)
iter := ParseString(`12.3`)
val := iter.ReadBigFloat()
val64, _ := val.Float64()
should.Equal(12.3, val64)
@ -19,7 +19,7 @@ func Test_read_big_float(t *testing.T) {
func Test_read_big_int(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `92233720368547758079223372036854775807`)
iter := ParseString(`92233720368547758079223372036854775807`)
val := iter.ReadBigInt()
should.NotNil(val)
should.Equal(`92233720368547758079223372036854775807`, val.String())
@ -31,14 +31,14 @@ func Test_read_float(t *testing.T) {
// non-streaming
t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, input+",")
iter := ParseString(input + ",")
expected, err := strconv.ParseFloat(input, 32)
should.Nil(err)
should.Equal(float32(expected), iter.ReadFloat32())
})
t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, input+",")
iter := ParseString(input + ",")
expected, err := strconv.ParseFloat(input, 64)
should.Nil(err)
should.Equal(expected, iter.ReadFloat64())
@ -46,14 +46,14 @@ func Test_read_float(t *testing.T) {
// streaming
t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
should := require.New(t)
iter := Parse(ConfigOfDefault, bytes.NewBufferString(input+","), 2)
iter := Parse(bytes.NewBufferString(input+","), 2)
expected, err := strconv.ParseFloat(input, 32)
should.Nil(err)
should.Equal(float32(expected), iter.ReadFloat32())
})
t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
should := require.New(t)
iter := Parse(ConfigOfDefault, bytes.NewBufferString(input+","), 2)
iter := Parse(bytes.NewBufferString(input+","), 2)
expected, err := strconv.ParseFloat(input, 64)
should.Nil(err)
should.Equal(expected, iter.ReadFloat64())
@ -63,7 +63,7 @@ func Test_read_float(t *testing.T) {
func Test_read_float_as_interface(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `12.3`)
iter := ParseString(`12.3`)
should.Equal(float64(12.3), iter.Read())
}
@ -90,7 +90,7 @@ func Test_write_float32(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteFloat32Lossy(val)
stream.Flush()
should.Nil(stream.Error)
@ -99,7 +99,7 @@ func Test_write_float32(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteVal(val)
stream.Flush()
should.Nil(stream.Error)
@ -108,7 +108,7 @@ func Test_write_float32(t *testing.T) {
}
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 10)
stream := NewStream(buf, 10)
stream.WriteRaw("abcdefg")
stream.WriteFloat32Lossy(1.123456)
stream.Flush()
@ -123,7 +123,7 @@ func Test_write_float64(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteFloat64Lossy(val)
stream.Flush()
should.Nil(stream.Error)
@ -132,7 +132,7 @@ func Test_write_float64(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteVal(val)
stream.Flush()
should.Nil(stream.Error)
@ -141,7 +141,7 @@ func Test_write_float64(t *testing.T) {
}
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 10)
stream := NewStream(buf, 10)
stream.WriteRaw("abcdefg")
stream.WriteFloat64Lossy(1.123456)
stream.Flush()
@ -151,7 +151,7 @@ func Test_write_float64(t *testing.T) {
func Test_read_float64_cursor(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, "[1.23456789\n,2,3]")
iter := ParseString("[1.23456789\n,2,3]")
should.True(iter.ReadArray())
should.Equal(1.23456789, iter.Read())
should.True(iter.ReadArray())
@ -174,7 +174,7 @@ func Test_read_float_scientific(t *testing.T) {
func Benchmark_jsoniter_float(b *testing.B) {
b.ReportAllocs()
input := []byte(`1.1123,`)
iter := NewIterator(ConfigOfDefault)
iter := NewIterator()
for n := 0; n < b.N; n++ {
iter.ResetBytes(input)
iter.ReadFloat64()

74
jsoniter_int_test.go
View File

@ -13,7 +13,7 @@ import (
func Test_read_uint64_invalid(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, ",")
iter := ParseString(",")
iter.ReadUint64()
should.NotNil(iter.Error)
}
@ -23,7 +23,7 @@ func Test_read_int8(t *testing.T) {
for _, input := range inputs {
t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, input)
iter := ParseString(input)
expected, err := strconv.ParseInt(input, 10, 8)
should.Nil(err)
should.Equal(int8(expected), iter.ReadInt8())
@ -36,7 +36,7 @@ func Test_read_int16(t *testing.T) {
for _, input := range inputs {
t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, input)
iter := ParseString(input)
expected, err := strconv.ParseInt(input, 10, 16)
should.Nil(err)
should.Equal(int16(expected), iter.ReadInt16())
@ -49,14 +49,14 @@ func Test_read_int32(t *testing.T) {
for _, input := range inputs {
t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, input)
iter := ParseString(input)
expected, err := strconv.ParseInt(input, 10, 32)
should.Nil(err)
should.Equal(int32(expected), iter.ReadInt32())
})
t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
should := require.New(t)
iter := Parse(ConfigOfDefault, bytes.NewBufferString(input), 2)
iter := Parse(bytes.NewBufferString(input), 2)
expected, err := strconv.ParseInt(input, 10, 32)
should.Nil(err)
should.Equal(int32(expected), iter.ReadInt32())
@ -83,7 +83,7 @@ func Test_read_int64_array(t *testing.T) {
func Test_read_int32_overflow(t *testing.T) {
should := require.New(t)
input := "123456789123456789,"
iter := ParseString(ConfigOfDefault, input)
iter := ParseString(input)
iter.ReadInt32()
should.NotNil(iter.Error)
}
@ -93,14 +93,14 @@ func Test_read_int64(t *testing.T) {
for _, input := range inputs {
t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, input)
iter := ParseString(input)
expected, err := strconv.ParseInt(input, 10, 64)
should.Nil(err)
should.Equal(expected, iter.ReadInt64())
})
t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
should := require.New(t)
iter := Parse(ConfigOfDefault, bytes.NewBufferString(input), 2)
iter := Parse(bytes.NewBufferString(input), 2)
expected, err := strconv.ParseInt(input, 10, 64)
should.Nil(err)
should.Equal(expected, iter.ReadInt64())
@ -111,7 +111,7 @@ func Test_read_int64(t *testing.T) {
func Test_read_int64_overflow(t *testing.T) {
should := require.New(t)
input := "123456789123456789123456789123456789,"
iter := ParseString(ConfigOfDefault, input)
iter := ParseString(input)
iter.ReadInt64()
should.NotNil(iter.Error)
}
@ -146,7 +146,7 @@ func Test_write_uint8(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteUint8(val)
stream.Flush()
should.Nil(stream.Error)
@ -155,7 +155,7 @@ func Test_write_uint8(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteVal(val)
stream.Flush()
should.Nil(stream.Error)
@ -164,7 +164,7 @@ func Test_write_uint8(t *testing.T) {
}
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 3)
stream := NewStream(buf, 3)
stream.WriteRaw("a")
stream.WriteUint8(100) // should clear buffer
stream.Flush()
@ -178,7 +178,7 @@ func Test_write_int8(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteInt8(val)
stream.Flush()
should.Nil(stream.Error)
@ -187,7 +187,7 @@ func Test_write_int8(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteVal(val)
stream.Flush()
should.Nil(stream.Error)
@ -196,7 +196,7 @@ func Test_write_int8(t *testing.T) {
}
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4)
stream := NewStream(buf, 4)
stream.WriteRaw("a")
stream.WriteInt8(-100) // should clear buffer
stream.Flush()
@ -210,7 +210,7 @@ func Test_write_uint16(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteUint16(val)
stream.Flush()
should.Nil(stream.Error)
@ -219,7 +219,7 @@ func Test_write_uint16(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteVal(val)
stream.Flush()
should.Nil(stream.Error)
@ -228,7 +228,7 @@ func Test_write_uint16(t *testing.T) {
}
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 5)
stream := NewStream(buf, 5)
stream.WriteRaw("a")
stream.WriteUint16(10000) // should clear buffer
stream.Flush()
@ -242,7 +242,7 @@ func Test_write_int16(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteInt16(val)
stream.Flush()
should.Nil(stream.Error)
@ -251,7 +251,7 @@ func Test_write_int16(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteVal(val)
stream.Flush()
should.Nil(stream.Error)
@ -260,7 +260,7 @@ func Test_write_int16(t *testing.T) {
}
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 6)
stream := NewStream(buf, 6)
stream.WriteRaw("a")
stream.WriteInt16(-10000) // should clear buffer
stream.Flush()
@ -274,7 +274,7 @@ func Test_write_uint32(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteUint32(val)
stream.Flush()
should.Nil(stream.Error)
@ -283,7 +283,7 @@ func Test_write_uint32(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteVal(val)
stream.Flush()
should.Nil(stream.Error)
@ -292,7 +292,7 @@ func Test_write_uint32(t *testing.T) {
}
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 10)
stream := NewStream(buf, 10)
stream.WriteRaw("a")
stream.WriteUint32(0xffffffff) // should clear buffer
stream.Flush()
@ -306,7 +306,7 @@ func Test_write_int32(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteInt32(val)
stream.Flush()
should.Nil(stream.Error)
@ -315,7 +315,7 @@ func Test_write_int32(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteVal(val)
stream.Flush()
should.Nil(stream.Error)
@ -324,7 +324,7 @@ func Test_write_int32(t *testing.T) {
}
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 11)
stream := NewStream(buf, 11)
stream.WriteRaw("a")
stream.WriteInt32(-0x7fffffff) // should clear buffer
stream.Flush()
@ -340,7 +340,7 @@ func Test_write_uint64(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteUint64(val)
stream.Flush()
should.Nil(stream.Error)
@ -349,7 +349,7 @@ func Test_write_uint64(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteVal(val)
stream.Flush()
should.Nil(stream.Error)
@ -358,7 +358,7 @@ func Test_write_uint64(t *testing.T) {
}
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 10)
stream := NewStream(buf, 10)
stream.WriteRaw("a")
stream.WriteUint64(0xffffffff) // should clear buffer
stream.Flush()
@ -374,7 +374,7 @@ func Test_write_int64(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteInt64(val)
stream.Flush()
should.Nil(stream.Error)
@ -383,7 +383,7 @@ func Test_write_int64(t *testing.T) {
t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteVal(val)
stream.Flush()
should.Nil(stream.Error)
@ -392,7 +392,7 @@ func Test_write_int64(t *testing.T) {
}
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 10)
stream := NewStream(buf, 10)
stream.WriteRaw("a")
stream.WriteInt64(0xffffffff) // should clear buffer
stream.Flush()
@ -403,7 +403,7 @@ func Test_write_int64(t *testing.T) {
func Test_write_val_int(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteVal(1001)
stream.Flush()
should.Nil(stream.Error)
@ -413,7 +413,7 @@ func Test_write_val_int(t *testing.T) {
func Test_write_val_int_ptr(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
val := 1001
stream.WriteVal(&val)
stream.Flush()
@ -433,7 +433,7 @@ func Test_json_number(t *testing.T) {
}
func Benchmark_jsoniter_encode_int(b *testing.B) {
stream := NewStream(ConfigOfDefault, ioutil.Discard, 64)
stream := NewStream(ioutil.Discard, 64)
for n := 0; n < b.N; n++ {
stream.n = 0
stream.WriteUint64(0xffffffff)
@ -447,7 +447,7 @@ func Benchmark_itoa(b *testing.B) {
}
func Benchmark_jsoniter_int(b *testing.B) {
iter := NewIterator(ConfigOfDefault)
iter := NewIterator()
input := []byte(`100`)
for n := 0; n < b.N; n++ {
iter.ResetBytes(input)

7
jsoniter_interface_test.go
View File

@ -1,10 +1,10 @@
package jsoniter
import (
"encoding/json"
"github.com/json-iterator/go/require"
"testing"
"unsafe"
"encoding/json"
)
func Test_write_array_of_interface(t *testing.T) {
@ -140,9 +140,10 @@ func Test_encode_object_contain_non_empty_interface(t *testing.T) {
should.Equal(`{"Field":"hello"}`, str)
}
func Test_nil_non_empty_interface(t *testing.T) {
ConfigOfDefault.CleanEncoders()
ConfigOfDefault.CleanDecoders()
CleanEncoders()
CleanDecoders()
type TestObject struct {
Field []MyInterface
}

6
jsoniter_io_test.go
View File

@ -7,7 +7,7 @@ import (
)
func Test_read_by_one(t *testing.T) {
iter := Parse(ConfigOfDefault, bytes.NewBufferString("abc"), 1)
iter := Parse(bytes.NewBufferString("abc"), 1)
b := iter.readByte()
if iter.Error != nil {
t.Fatal(iter.Error)
@ -34,7 +34,7 @@ func Test_read_by_one(t *testing.T) {
}
func Test_read_by_two(t *testing.T) {
iter := Parse(ConfigOfDefault, bytes.NewBufferString("abc"), 2)
iter := Parse(bytes.NewBufferString("abc"), 2)
b := iter.readByte()
if iter.Error != nil {
t.Fatal(iter.Error)
@ -67,7 +67,7 @@ func Test_read_by_two(t *testing.T) {
}
func Test_read_until_eof(t *testing.T) {
iter := Parse(ConfigOfDefault, bytes.NewBufferString("abc"), 2)
iter := Parse(bytes.NewBufferString("abc"), 2)
iter.readByte()
iter.readByte()
b := iter.readByte()

2
jsoniter_large_file_test.go
View File

@ -27,7 +27,7 @@ func Benchmark_jsoniter_large_file(b *testing.B) {
b.ReportAllocs()
for n := 0; n < b.N; n++ {
file, _ := os.Open("/tmp/large-file.json")
iter := Parse(ConfigOfDefault, file, 4096)
iter := Parse(file, 4096)
count := 0
for iter.ReadArray() {
iter.Skip()

28
jsoniter_map_test.go
View File

@ -1,15 +1,15 @@
package jsoniter
import (
"encoding/json"
"github.com/json-iterator/go/require"
"math/big"
"testing"
"encoding/json"
)
func Test_read_map(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `{"hello": "world"}`)
iter := ParseString(`{"hello": "world"}`)
m := map[string]string{"1": "2"}
iter.ReadVal(&m)
copy(iter.buf, []byte{0, 0, 0, 0, 0, 0})
@ -18,11 +18,11 @@ func Test_read_map(t *testing.T) {
func Test_read_map_of_interface(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `{"hello": "world"}`)
iter := ParseString(`{"hello": "world"}`)
m := map[string]interface{}{"1": "2"}
iter.ReadVal(&m)
should.Equal(map[string]interface{}{"1": "2", "hello": "world"}, m)
iter = ParseString(ConfigOfDefault, `{"hello": "world"}`)
iter = ParseString(`{"hello": "world"}`)
should.Equal(map[string]interface{}{"hello": "world"}, iter.Read())
}
@ -103,6 +103,8 @@ func Test_decode_TextMarshaler_key_map(t *testing.T) {
should.Equal(`{"1":"2"}`, str)
}
func Test_map_key_with_escaped_char(t *testing.T) {
type Ttest struct {
Map map[string]string
@ -117,25 +119,11 @@ func Test_map_key_with_escaped_char(t *testing.T) {
{
var obj Ttest
should.Nil(json.Unmarshal(jsonBytes, &obj))
should.Equal(map[string]string{"k\"ey": "val"}, obj.Map)
should.Equal(map[string]string{"k\"ey":"val"}, obj.Map)
}
{
var obj Ttest
should.Nil(Unmarshal(jsonBytes, &obj))
should.Equal(map[string]string{"k\"ey": "val"}, obj.Map)
should.Equal(map[string]string{"k\"ey":"val"}, obj.Map)
}
}
func Test_encode_map_with_sorted_keys(t *testing.T) {
should := require.New(t)
m := map[string]interface{}{
"3": 3,
"1": 1,
"2": 2,
}
bytes, err := json.Marshal(m)
should.Nil(err)
output, err := ConfigCompatibleWithStandardLibrary.MarshalToString(m)
should.Nil(err)
should.Equal(string(bytes), output)
}

4
jsoniter_nested_test.go
View File

@ -15,7 +15,7 @@ type Level2 struct {
}
func Test_nested(t *testing.T) {
iter := ParseString(ConfigOfDefault, `{"hello": [{"world": "value1"}, {"world": "value2"}]}`)
iter := ParseString(`{"hello": [{"world": "value1"}, {"world": "value2"}]}`)
l1 := Level1{}
for l1Field := iter.ReadObject(); l1Field != ""; l1Field = iter.ReadObject() {
switch l1Field {
@ -50,7 +50,7 @@ func Test_nested(t *testing.T) {
func Benchmark_jsoniter_nested(b *testing.B) {
for n := 0; n < b.N; n++ {
iter := ParseString(ConfigOfDefault, `{"hello": [{"world": "value1"}, {"world": "value2"}]}`)
iter := ParseString(`{"hello": [{"world": "value1"}, {"world": "value2"}]}`)
l1 := Level1{}
for l1Field := iter.ReadObject(); l1Field != ""; l1Field = iter.ReadObject() {
switch l1Field {

53
jsoniter_null_test.go
View File

@ -2,18 +2,17 @@ package jsoniter
import (
"bytes"
"encoding/json"
"github.com/json-iterator/go/require"
"testing"
)
func Test_read_null(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `null`)
iter := ParseString(`null`)
should.True(iter.ReadNil())
iter = ParseString(ConfigOfDefault, `null`)
iter = ParseString(`null`)
should.Nil(iter.Read())
iter = ParseString(ConfigOfDefault, `null`)
iter = ParseString(`null`)
any, err := UnmarshalAnyFromString(`null`)
should.Nil(err)
should.Equal(0, any.ToInt())
@ -25,7 +24,7 @@ func Test_read_null(t *testing.T) {
func Test_write_null(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteNil()
stream.Flush()
should.Nil(stream.Error)
@ -41,7 +40,7 @@ func Test_encode_null(t *testing.T) {
func Test_decode_null_object(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `[null,"a"]`)
iter := ParseString(`[null,"a"]`)
iter.ReadArray()
if iter.ReadObject() != "" {
t.FailNow()
@ -59,7 +58,7 @@ func Test_decode_null_object(t *testing.T) {
}
func Test_decode_null_array(t *testing.T) {
iter := ParseString(ConfigOfDefault, `[null,"a"]`)
iter := ParseString(`[null,"a"]`)
iter.ReadArray()
if iter.ReadArray() != false {
t.FailNow()
@ -72,7 +71,7 @@ func Test_decode_null_array(t *testing.T) {
func Test_decode_null_string(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `[null,"a"]`)
iter := ParseString(`[null,"a"]`)
should.True(iter.ReadArray())
should.Equal("", iter.ReadString())
should.True(iter.ReadArray())
@ -80,7 +79,7 @@ func Test_decode_null_string(t *testing.T) {
}
func Test_decode_null_skip(t *testing.T) {
iter := ParseString(ConfigOfDefault, `[null,"a"]`)
iter := ParseString(`[null,"a"]`)
iter.ReadArray()
iter.Skip()
iter.ReadArray()
@ -88,39 +87,3 @@ func Test_decode_null_skip(t *testing.T) {
t.FailNow()
}
}
func Test_encode_nil_map(t *testing.T) {
should := require.New(t)
type Ttest map[string]string
var obj1 Ttest
output, err := json.Marshal(obj1)
should.Nil(err)
should.Equal("null", string(output))
output, err = json.Marshal(&obj1)
should.Nil(err)
should.Equal("null", string(output))
output, err = Marshal(obj1)
should.Nil(err)
should.Equal("null", string(output))
output, err = Marshal(&obj1)
should.Nil(err)
should.Equal("null", string(output))
}
func Test_encode_nil_array(t *testing.T) {
should := require.New(t)
type Ttest []string
var obj1 Ttest
output, err := json.Marshal(obj1)
should.Nil(err)
should.Equal("null", string(output))
output, err = json.Marshal(&obj1)
should.Nil(err)
should.Equal("null", string(output))
output, err = Marshal(obj1)
should.Nil(err)
should.Equal("null", string(output))
output, err = Marshal(&obj1)
should.Nil(err)
should.Equal("null", string(output))
}

17
jsoniter_object_test.go
View File

@ -9,10 +9,10 @@ import (
func Test_empty_object(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `{}`)
iter := ParseString(`{}`)
field := iter.ReadObject()
should.Equal("", field)
iter = ParseString(ConfigOfDefault, `{}`)
iter = ParseString(`{}`)
iter.ReadObjectCB(func(iter *Iterator, field string) bool {
should.FailNow("should not call")
return true
@ -21,14 +21,14 @@ func Test_empty_object(t *testing.T) {
func Test_one_field(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `{"a": "b"}`)
iter := ParseString(`{"a": "b"}`)
field := iter.ReadObject()
should.Equal("a", field)
value := iter.ReadString()
should.Equal("b", value)
field = iter.ReadObject()
should.Equal("", field)
iter = ParseString(ConfigOfDefault, `{"a": "b"}`)
iter = ParseString(`{"a": "b"}`)
should.True(iter.ReadObjectCB(func(iter *Iterator, field string) bool {
should.Equal("a", field)
return true
@ -37,7 +37,7 @@ func Test_one_field(t *testing.T) {
func Test_two_field(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `{ "a": "b" , "c": "d" }`)
iter := ParseString(`{ "a": "b" , "c": "d" }`)
field := iter.ReadObject()
should.Equal("a", field)
value := iter.ReadString()
@ -48,7 +48,7 @@ func Test_two_field(t *testing.T) {
should.Equal("d", value)
field = iter.ReadObject()
should.Equal("", field)
iter = ParseString(ConfigOfDefault, `{"field1": "1", "field2": 2}`)
iter = ParseString(`{"field1": "1", "field2": 2}`)
for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
switch field {
case "field1":
@ -210,7 +210,8 @@ func Test_object_wrapper_any_get_all(t *testing.T) {
func Test_write_object(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(Config{IndentionStep: 2}.Froze(), buf, 4096)
stream := NewStream(buf, 4096)
stream.IndentionStep = 2
stream.WriteObjectStart()
stream.WriteObjectField("hello")
stream.WriteInt(1)
@ -229,7 +230,7 @@ func Benchmark_jsoniter_object(b *testing.B) {
Field2 uint64
}
for n := 0; n < b.N; n++ {
iter := ParseString(ConfigOfDefault, `{"field1": "1", "field2": 2}`)
iter := ParseString(`{"field1": "1", "field2": 2}`)
obj := TestObj{}
for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
switch field {

18
jsoniter_optional_test.go
View File

@ -21,26 +21,26 @@ func Test_encode_optional_int_pointer(t *testing.T) {
func Test_decode_struct_with_optional_field(t *testing.T) {
should := require.New(t)
type TestObject struct {
Field1 *string
Field2 *string
field1 *string
field2 *string
}
obj := TestObject{}
UnmarshalFromString(`{"field1": null, "field2": "world"}`, &obj)
should.Nil(obj.Field1)
should.Equal("world", *obj.Field2)
should.Nil(obj.field1)
should.Equal("world", *obj.field2)
}
func Test_encode_struct_with_optional_field(t *testing.T) {
should := require.New(t)
type TestObject struct {
Field1 *string
Field2 *string
field1 *string
field2 *string
}
obj := TestObject{}
world := "world"
obj.Field2 = &world
obj.field2 = &world
str, err := MarshalToString(obj)
should.Nil(err)
should.Contains(str, `"Field1":null`)
should.Contains(str, `"Field2":"world"`)
should.Contains(str, `"field1":null`)
should.Contains(str, `"field2":"world"`)
}

32
jsoniter_reflect_native_test.go
View File

@ -6,7 +6,7 @@ import (
)
func Test_reflect_str(t *testing.T) {
iter := ParseString(ConfigOfDefault, `"hello"`)
iter := ParseString(`"hello"`)
str := ""
iter.ReadVal(&str)
if str != "hello" {
@ -16,7 +16,7 @@ func Test_reflect_str(t *testing.T) {
}
func Test_reflect_ptr_str(t *testing.T) {
iter := ParseString(ConfigOfDefault, `"hello"`)
iter := ParseString(`"hello"`)
var str *string
iter.ReadVal(&str)
if *str != "hello" {
@ -25,7 +25,7 @@ func Test_reflect_ptr_str(t *testing.T) {
}
func Test_reflect_int(t *testing.T) {
iter := ParseString(ConfigOfDefault, `123`)
iter := ParseString(`123`)
val := int(0)
iter.ReadVal(&val)
if val != 123 {
@ -34,7 +34,7 @@ func Test_reflect_int(t *testing.T) {
}
func Test_reflect_int8(t *testing.T) {
iter := ParseString(ConfigOfDefault, `123`)
iter := ParseString(`123`)
val := int8(0)
iter.ReadVal(&val)
if val != 123 {
@ -43,7 +43,7 @@ func Test_reflect_int8(t *testing.T) {
}
func Test_reflect_int16(t *testing.T) {
iter := ParseString(ConfigOfDefault, `123`)
iter := ParseString(`123`)
val := int16(0)
iter.ReadVal(&val)
if val != 123 {
@ -52,7 +52,7 @@ func Test_reflect_int16(t *testing.T) {
}
func Test_reflect_int32(t *testing.T) {
iter := ParseString(ConfigOfDefault, `123`)
iter := ParseString(`123`)
val := int32(0)
iter.ReadVal(&val)
if val != 123 {
@ -61,7 +61,7 @@ func Test_reflect_int32(t *testing.T) {
}
func Test_reflect_int64(t *testing.T) {
iter := ParseString(ConfigOfDefault, `123`)
iter := ParseString(`123`)
val := int64(0)
iter.ReadVal(&val)
if val != 123 {
@ -70,7 +70,7 @@ func Test_reflect_int64(t *testing.T) {
}
func Test_reflect_uint(t *testing.T) {
iter := ParseString(ConfigOfDefault, `123`)
iter := ParseString(`123`)
val := uint(0)
iter.ReadVal(&val)
if val != 123 {
@ -79,7 +79,7 @@ func Test_reflect_uint(t *testing.T) {
}
func Test_reflect_uint8(t *testing.T) {
iter := ParseString(ConfigOfDefault, `123`)
iter := ParseString(`123`)
val := uint8(0)
iter.ReadVal(&val)
if val != 123 {
@ -88,7 +88,7 @@ func Test_reflect_uint8(t *testing.T) {
}
func Test_reflect_uint16(t *testing.T) {
iter := ParseString(ConfigOfDefault, `123`)
iter := ParseString(`123`)
val := uint16(0)
iter.ReadVal(&val)
if val != 123 {
@ -97,7 +97,7 @@ func Test_reflect_uint16(t *testing.T) {
}
func Test_reflect_uint32(t *testing.T) {
iter := ParseString(ConfigOfDefault, `123`)
iter := ParseString(`123`)
val := uint32(0)
iter.ReadVal(&val)
if val != 123 {
@ -106,7 +106,7 @@ func Test_reflect_uint32(t *testing.T) {
}
func Test_reflect_uint64(t *testing.T) {
iter := ParseString(ConfigOfDefault, `123`)
iter := ParseString(`123`)
val := uint64(0)
iter.ReadVal(&val)
if val != 123 {
@ -115,7 +115,7 @@ func Test_reflect_uint64(t *testing.T) {
}
func Test_reflect_byte(t *testing.T) {
iter := ParseString(ConfigOfDefault, `123`)
iter := ParseString(`123`)
val := byte(0)
iter.ReadVal(&val)
if val != 123 {
@ -124,7 +124,7 @@ func Test_reflect_byte(t *testing.T) {
}
func Test_reflect_float32(t *testing.T) {
iter := ParseString(ConfigOfDefault, `1.23`)
iter := ParseString(`1.23`)
val := float32(0)
iter.ReadVal(&val)
if val != 1.23 {
@ -134,7 +134,7 @@ func Test_reflect_float32(t *testing.T) {
}
func Test_reflect_float64(t *testing.T) {
iter := ParseString(ConfigOfDefault, `1.23`)
iter := ParseString(`1.23`)
val := float64(0)
iter.ReadVal(&val)
if val != 1.23 {
@ -144,7 +144,7 @@ func Test_reflect_float64(t *testing.T) {
}
func Test_reflect_bool(t *testing.T) {
iter := ParseString(ConfigOfDefault, `true`)
iter := ParseString(`true`)
val := false
iter.ReadVal(&val)
if val != true {

18
jsoniter_reflect_test.go
View File

@ -24,17 +24,17 @@ func Test_decode_large_slice(t *testing.T) {
func Test_decode_nested(t *testing.T) {
type StructOfString struct {
Field1 string
Field2 string
field1 string
field2 string
}
iter := ParseString(ConfigOfDefault, `[{"field1": "hello"}, null, {"field2": "world"}]`)
iter := ParseString(`[{"field1": "hello"}, null, {"field2": "world"}]`)
slice := []*StructOfString{}
iter.ReadVal(&slice)
if len(slice) != 3 {
fmt.Println(iter.Error)
t.Fatal(len(slice))
}
if slice[0].Field1 != "hello" {
if slice[0].field1 != "hello" {
fmt.Println(iter.Error)
t.Fatal(slice[0])
}
@ -42,19 +42,19 @@ func Test_decode_nested(t *testing.T) {
fmt.Println(iter.Error)
t.Fatal(slice[1])
}
if slice[2].Field2 != "world" {
if slice[2].field2 != "world" {
fmt.Println(iter.Error)
t.Fatal(slice[2])
}
}
func Test_decode_base64(t *testing.T) {
iter := ParseString(ConfigOfDefault, `"YWJj"`)
iter := ParseString(`"YWJj"`)
val := []byte{}
RegisterTypeDecoder("[]uint8", func(ptr unsafe.Pointer, iter *Iterator) {
*((*[]byte)(ptr)) = iter.ReadBase64()
})
defer ConfigOfDefault.CleanDecoders()
defer CleanDecoders()
iter.ReadVal(&val)
if "abc" != string(val) {
t.Fatal(string(val))
@ -70,7 +70,7 @@ type StructOfTagOne struct {
func Benchmark_jsoniter_reflect(b *testing.B) {
b.ReportAllocs()
iter := NewIterator(ConfigOfDefault)
iter := NewIterator()
Struct := &StructOfTagOne{}
//var Struct *StructOfTagOne
input := []byte(`{"field3": "100", "field4": "100"}`)
@ -96,7 +96,7 @@ func Benchmark_jsoniter_direct(b *testing.B) {
// iter.Skip()
// }
//}
iter := ParseString(ConfigOfDefault, `["hello", "world"]`)
iter := ParseString(`["hello", "world"]`)
array := make([]string, 0, 2)
for iter.ReadArray() {
array = append(array, iter.ReadString())

16
jsoniter_skip_test.go
View File

@ -6,7 +6,7 @@ import (
)
func Test_skip_number(t *testing.T) {
iter := ParseString(ConfigOfDefault, `[-0.12, "b"]`)
iter := ParseString(`[-0.12, "b"]`)
iter.ReadArray()
iter.Skip()
iter.ReadArray()
@ -16,7 +16,7 @@ func Test_skip_number(t *testing.T) {
}
func Test_skip_null(t *testing.T) {
iter := ParseString(ConfigOfDefault, `[null , "b"]`)
iter := ParseString(`[null , "b"]`)
iter.ReadArray()
iter.Skip()
iter.ReadArray()
@ -26,7 +26,7 @@ func Test_skip_null(t *testing.T) {
}
func Test_skip_true(t *testing.T) {
iter := ParseString(ConfigOfDefault, `[true , "b"]`)
iter := ParseString(`[true , "b"]`)
iter.ReadArray()
iter.Skip()
iter.ReadArray()
@ -36,7 +36,7 @@ func Test_skip_true(t *testing.T) {
}
func Test_skip_false(t *testing.T) {
iter := ParseString(ConfigOfDefault, `[false , "b"]`)
iter := ParseString(`[false , "b"]`)
iter.ReadArray()
iter.Skip()
iter.ReadArray()
@ -46,7 +46,7 @@ func Test_skip_false(t *testing.T) {
}
func Test_skip_array(t *testing.T) {
iter := ParseString(ConfigOfDefault, `[[1, [2, [3], 4]], "b"]`)
iter := ParseString(`[[1, [2, [3], 4]], "b"]`)
iter.ReadArray()
iter.Skip()
iter.ReadArray()
@ -56,7 +56,7 @@ func Test_skip_array(t *testing.T) {
}
func Test_skip_empty_array(t *testing.T) {
iter := ParseString(ConfigOfDefault, `[ [ ], "b"]`)
iter := ParseString(`[ [ ], "b"]`)
iter.ReadArray()
iter.Skip()
iter.ReadArray()
@ -66,7 +66,7 @@ func Test_skip_empty_array(t *testing.T) {
}
func Test_skip_nested(t *testing.T) {
iter := ParseString(ConfigOfDefault, `[ {"a" : [{"b": "c"}], "d": 102 }, "b"]`)
iter := ParseString(`[ {"a" : [{"b": "c"}], "d": 102 }, "b"]`)
iter.ReadArray()
iter.Skip()
iter.ReadArray()
@ -106,7 +106,7 @@ func Benchmark_jsoniter_skip(b *testing.B) {
}`)
for n := 0; n < b.N; n++ {
result := TestResp{}
iter := ParseBytes(ConfigOfDefault, input)
iter := ParseBytes(input)
for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
switch field {
case "code":

11
jsoniter_stream_test.go
View File

@ -7,7 +7,7 @@ import (
func Test_writeByte_should_grow_buffer(t *testing.T) {
should := require.New(t)
stream := NewStream(ConfigOfDefault, nil, 1)
stream := NewStream(nil, 1)
stream.writeByte('1')
should.Equal("1", string(stream.Buffer()))
should.Equal(1, len(stream.buf))
@ -20,7 +20,7 @@ func Test_writeByte_should_grow_buffer(t *testing.T) {
func Test_writeBytes_should_grow_buffer(t *testing.T) {
should := require.New(t)
stream := NewStream(ConfigOfDefault, nil, 1)
stream := NewStream(nil, 1)
stream.Write([]byte{'1', '2'})
should.Equal("12", string(stream.Buffer()))
should.Equal(3, len(stream.buf))
@ -31,14 +31,15 @@ func Test_writeBytes_should_grow_buffer(t *testing.T) {
func Test_writeIndention_should_grow_buffer(t *testing.T) {
should := require.New(t)
stream := NewStream(Config{IndentionStep: 2}.Froze(), nil, 1)
stream := NewStream(nil, 1)
stream.IndentionStep = 2
stream.WriteVal([]int{1, 2, 3})
should.Equal("[\n 1,\n 2,\n 3\n]", string(stream.Buffer()))
}
func Test_writeRaw_should_grow_buffer(t *testing.T) {
should := require.New(t)
stream := NewStream(ConfigOfDefault, nil, 1)
stream := NewStream(nil, 1)
stream.WriteRaw("123")
should.Nil(stream.Error)
should.Equal("123", string(stream.Buffer()))
@ -46,7 +47,7 @@ func Test_writeRaw_should_grow_buffer(t *testing.T) {
func Test_writeString_should_grow_buffer(t *testing.T) {
should := require.New(t)
stream := NewStream(ConfigOfDefault, nil, 0)
stream := NewStream(nil, 0)
stream.WriteString("123")
should.Nil(stream.Error)
should.Equal(`"123"`, string(stream.Buffer()))

65
jsoniter_string_test.go
View File

@ -6,7 +6,6 @@ import (
"fmt"
"github.com/json-iterator/go/require"
"testing"
"unicode/utf8"
)
func Test_read_normal_string(t *testing.T) {
@ -18,22 +17,22 @@ func Test_read_normal_string(t *testing.T) {
for input, output := range cases {
t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, input)
iter := ParseString(input)
should.Equal(output, iter.ReadString())
})
t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
should := require.New(t)
iter := Parse(ConfigOfDefault, bytes.NewBufferString(input), 2)
iter := Parse(bytes.NewBufferString(input), 2)
should.Equal(output, iter.ReadString())
})
t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, input)
iter := ParseString(input)
should.Equal(output, string(iter.ReadStringAsSlice()))
})
t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
should := require.New(t)
iter := Parse(ConfigOfDefault, bytes.NewBufferString(input), 2)
iter := Parse(bytes.NewBufferString(input), 2)
should.Equal(output, string(iter.ReadStringAsSlice()))
})
}
@ -49,12 +48,12 @@ func Test_read_exotic_string(t *testing.T) {
for input, output := range cases {
t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, input)
iter := ParseString(input)
should.Equal(output, iter.ReadString())
})
t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
should := require.New(t)
iter := Parse(ConfigOfDefault, bytes.NewBufferString(input), 2)
iter := Parse(bytes.NewBufferString(input), 2)
should.Equal(output, iter.ReadString())
})
}
@ -62,7 +61,7 @@ func Test_read_exotic_string(t *testing.T) {
func Test_read_string_as_interface(t *testing.T) {
should := require.New(t)
iter := ParseString(ConfigOfDefault, `"hello"`)
iter := ParseString(`"hello"`)
should.Equal("hello", iter.Read())
}
@ -99,7 +98,7 @@ func Test_write_string(t *testing.T) {
func Test_write_val_string(t *testing.T) {
should := require.New(t)
buf := &bytes.Buffer{}
stream := NewStream(ConfigOfDefault, buf, 4096)
stream := NewStream(buf, 4096)
stream.WriteVal("hello")
stream.Flush()
should.Nil(stream.Error)
@ -113,57 +112,15 @@ func Test_decode_slash(t *testing.T) {
should.NotNil(UnmarshalFromString("\\", &obj))
}
func Test_html_escape(t *testing.T) {
should := require.New(t)
output, err := json.Marshal(`>`)
should.Nil(err)
should.Equal(`"\u003e"`, string(output))
output, err = ConfigCompatibleWithStandardLibrary.Marshal(`>`)
should.Nil(err)
should.Equal(`"\u003e"`, string(output))
}
func Test_string_encode_with_std(t *testing.T) {
should := require.New(t)
for i := 0; i < utf8.RuneSelf; i++ {
input := string([]byte{byte(i)})
stdOutputBytes, err := json.Marshal(input)
should.Nil(err)
stdOutput := string(stdOutputBytes)
jsoniterOutputBytes, err := ConfigCompatibleWithStandardLibrary.Marshal(input)
should.Nil(err)
jsoniterOutput := string(jsoniterOutputBytes)
should.Equal(stdOutput, jsoniterOutput)
}
}
func Test_string_encode_with_std_without_html_escape(t *testing.T) {
should := require.New(t)
for i := 0; i < utf8.RuneSelf; i++ {
input := string([]byte{byte(i)})
buf := &bytes.Buffer{}
encoder := json.NewEncoder(buf)
encoder.SetEscapeHTML(false)
err := encoder.Encode(input)
should.Nil(err)
stdOutput := buf.String()
stdOutput = stdOutput[:len(stdOutput) - 1]
jsoniterOutputBytes, err := Marshal(input)
should.Nil(err)
jsoniterOutput := string(jsoniterOutputBytes)
should.Equal(stdOutput, jsoniterOutput)
}
}
func Benchmark_jsoniter_unicode(b *testing.B) {
for n := 0; n < b.N; n++ {
iter := ParseString(ConfigOfDefault, `"\ud83d\udc4a"`)
iter := ParseString(`"\ud83d\udc4a"`)
iter.ReadString()
}
}
func Benchmark_jsoniter_ascii(b *testing.B) {
iter := NewIterator(ConfigOfDefault)
iter := NewIterator()
input := []byte(`"hello, world! hello, world!"`)
b.ResetTimer()
for n := 0; n < b.N; n++ {
@ -173,7 +130,7 @@ func Benchmark_jsoniter_ascii(b *testing.B) {
}
func Benchmark_jsoniter_string_as_bytes(b *testing.B) {
iter := ParseString(ConfigOfDefault, `"hello, world!"`)
iter := ParseString(`"hello, world!"`)
b.ResetTimer()
for n := 0; n < b.N; n++ {
iter.ResetBytes(iter.buf)

144
output_tests/builtins/bool/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/bool/types.go
View File

@ -1,3 +0,0 @@
package test
type T bool

144
output_tests/builtins/bool_alias/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/bool_alias/types.go
View File

@ -1,3 +0,0 @@
package test
type T bool

144
output_tests/builtins/byte/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/byte/types.go
View File

@ -1,3 +0,0 @@
package test
type T byte

144
output_tests/builtins/byte_alias/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/byte_alias/types.go
View File

@ -1,3 +0,0 @@
package test
type T byte

144
output_tests/builtins/float32/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/float32/types.go
View File

@ -1,3 +0,0 @@
package test
type T float32

144
output_tests/builtins/float32_alias/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/float32_alias/types.go
View File

@ -1,3 +0,0 @@
package test
type T float32

144
output_tests/builtins/float64/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/float64/types.go
View File

@ -1,3 +0,0 @@
package test
type T float64

144
output_tests/builtins/float64_alias/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/float64_alias/types.go
View File

@ -1,3 +0,0 @@
package test
type T float64

144
output_tests/builtins/int16/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/int16/types.go
View File

@ -1,3 +0,0 @@
package test
type T int16

144
output_tests/builtins/int16_alias/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/int16_alias/types.go
View File

@ -1,3 +0,0 @@
package test
type T int16

144
output_tests/builtins/int32/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/int32/types.go
View File

@ -1,3 +0,0 @@
package test
type T int32

144
output_tests/builtins/int32_alias/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/int32_alias/types.go
View File

@ -1,3 +0,0 @@
package test
type T int32

144
output_tests/builtins/int8/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/int8/types.go
View File

@ -1,3 +0,0 @@
package test
type T int8

144
output_tests/builtins/int8_alias/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/int8_alias/types.go
View File

@ -1,3 +0,0 @@
package test
type T int8

144
output_tests/builtins/string/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/string/types.go
View File

@ -1,3 +0,0 @@
package test
type T string

144
output_tests/builtins/string_alias/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/string_alias/types.go
View File

@ -1,3 +0,0 @@
package test
type T string

144
output_tests/builtins/uint16/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/uint16/types.go
View File

@ -1,3 +0,0 @@
package test
type T uint16

144
output_tests/builtins/uint16_alias/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/uint16_alias/types.go
View File

@ -1,3 +0,0 @@
package test
type T uint16

144
output_tests/builtins/uint32/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/uint32/types.go
View File

@ -1,3 +0,0 @@
package test
type T uint32

144
output_tests/builtins/uint32_alias/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/uint32_alias/types.go
View File

@ -1,3 +0,0 @@
package test
type T uint32

144
output_tests/builtins/uint8/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/uint8/types.go
View File

@ -1,3 +0,0 @@
package test
type T uint8

144
output_tests/builtins/uint8_alias/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/builtins/uint8_alias/types.go
View File

@ -1,3 +0,0 @@
package test
type T uint8

144
output_tests/maps/builtins/int32/bool/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/maps/builtins/int32/bool/types.go
View File

@ -1,3 +0,0 @@
package test
type T map[int32]bool

144
output_tests/maps/builtins/int32/byte/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/maps/builtins/int32/byte/types.go
View File

@ -1,3 +0,0 @@
package test
type T map[int32]byte

144
output_tests/maps/builtins/int32/float32/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/maps/builtins/int32/float32/types.go
View File

@ -1,3 +0,0 @@
package test
type T map[int32]float32

144
output_tests/maps/builtins/int32/float64/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/maps/builtins/int32/float64/types.go
View File

@ -1,3 +0,0 @@
package test
type T map[int32]float64

144
output_tests/maps/builtins/int32/int32/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/maps/builtins/int32/int32/types.go
View File

@ -1,3 +0,0 @@
package test
type T map[int32]int32

144
output_tests/maps/builtins/int32/int8/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/maps/builtins/int32/int8/types.go
View File

@ -1,3 +0,0 @@
package test
type T map[int32]int8

144
output_tests/maps/builtins/int32/string/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

3
output_tests/maps/builtins/int32/string/types.go
View File

@ -1,3 +0,0 @@
package test
type T map[int32]string

144
output_tests/maps/builtins/int32/string_alias/json_test.go
View File

@ -1,144 +0,0 @@
package test
import (
"bytes"
"encoding/json"
"testing"
"github.com/davecgh/go-spew/spew"
fuzz "github.com/google/gofuzz"
jsoniter "github.com/json-iterator/go"
)
func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 1000; i++ {
var before T
fz.Fuzz(&before)
jbStd, err := json.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with stdlib: %v", err)
}
jbIter, err := jsoniter.Marshal(before)
if err != nil {
t.Errorf("failed to marshal with jsoniter: %v", err)
}
if string(jbStd) != string(jbIter) {
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
indent(jbStd, " "), indent(jbIter, " "), dump(before))
}
var afterStd T
err = json.Unmarshal(jbIter, &afterStd)
if err != nil {
t.Errorf("failed to unmarshal with stdlib: %v", err)
}
var afterIter T
err = jsoniter.Unmarshal(jbIter, &afterIter)
if err != nil {
t.Errorf("failed to unmarshal with jsoniter: %v", err)
}
if fingerprint(afterStd) != fingerprint(afterIter) {
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
dump(afterStd), dump(afterIter), indent(jbIter, " "))
}
}
}
const indentStr = "> "
func fingerprint(obj interface{}) string {
c := spew.ConfigState{
SortKeys: true,
SpewKeys: true,
}
return c.Sprintf("%v", obj)
}
func dump(obj interface{}) string {
cfg := spew.ConfigState{
Indent: indentStr,
}
return cfg.Sdump(obj)
}
func indent(src []byte, prefix string) string {
var buf bytes.Buffer
json.Indent(&buf, src, prefix, indentStr)
return buf.String()
}
func BenchmarkStandardMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := json.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkStandardUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = json.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}
func BenchmarkJSONIterMarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var obj T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj)
for i := 0; i < t.N; i++ {
jb, err := jsoniter.Marshal(obj)
if err != nil {
t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err)
}
_ = jb
}
}
func BenchmarkJSONIterUnmarshal(t *testing.B) {
t.ReportAllocs()
t.ResetTimer()
var before T
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before)
jb, err := json.Marshal(before)
if err != nil {
t.Fatalf("failed to marshal: %v", err)
}
for i := 0; i < t.N; i++ {
var after T
err = jsoniter.Unmarshal(jb, &after)
if err != nil {
t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err)
}
}
}

5
output_tests/maps/builtins/int32/string_alias/types.go
View File

@ -1,5 +0,0 @@
package test
type StringAlias string
type T map[int32]StringAlias

Some files were not shown because too many files have changed in this diff Show More