go/json-iterator
1
0
Fork 0
mirror of https://github.com/json-iterator/go.git synced 2024-11-27 08:30:57 +02:00
Code Issues Releases Activity

#53 support escapeHtml

Browse Source
This commit is contained in:
Tao Wen 2017-06-15 23:54:43 +08:00
parent d867c8ba5c
commit 5f22e50c89
30 changed files with 590 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
feature_adapter.go
View File

@ -26,7 +26,7 @@ import (
// Refer to https://godoc.org/encoding/json#Unmarshal for more information // Refer to https://godoc.org/encoding/json#Unmarshal for more information
func Unmarshal(data []byte, v interface{}) error { func Unmarshal(data []byte, v interface{}) error {
data = data[:lastNotSpacePos(data)] data = data[:lastNotSpacePos(data)]
iter := ParseBytes(DEFAULT_CONFIG, data) iter := ParseBytes(ConfigOfDefault, data)
typ := reflect.TypeOf(v) typ := reflect.TypeOf(v)
if typ.Kind() != reflect.Ptr { if typ.Kind() != reflect.Ptr {
// return non-pointer error // return non-pointer error
@ -48,7 +48,7 @@ func Unmarshal(data []byte, v interface{}) error {
// UnmarshalAny adapts to // UnmarshalAny adapts to
func UnmarshalAny(data []byte) (Any, error) { func UnmarshalAny(data []byte) (Any, error) {
data = data[:lastNotSpacePos(data)] data = data[:lastNotSpacePos(data)]
iter := ParseBytes(DEFAULT_CONFIG, data) iter := ParseBytes(ConfigOfDefault, data)
any := iter.ReadAny() any := iter.ReadAny()
if iter.head == iter.tail { if iter.head == iter.tail {
iter.loadMore() iter.loadMore()
@ -74,7 +74,7 @@ func lastNotSpacePos(data []byte) int {
func UnmarshalFromString(str string, v interface{}) error { func UnmarshalFromString(str string, v interface{}) error {
data := []byte(str) data := []byte(str)
data = data[:lastNotSpacePos(data)] data = data[:lastNotSpacePos(data)]
iter := ParseBytes(DEFAULT_CONFIG, data) iter := ParseBytes(ConfigOfDefault, data)
iter.ReadVal(v) iter.ReadVal(v)
if iter.head == iter.tail { if iter.head == iter.tail {
iter.loadMore() iter.loadMore()
@ -91,7 +91,7 @@ func UnmarshalFromString(str string, v interface{}) error {
func UnmarshalAnyFromString(str string) (Any, error) { func UnmarshalAnyFromString(str string) (Any, error) {
data := []byte(str) data := []byte(str)
data = data[:lastNotSpacePos(data)] data = data[:lastNotSpacePos(data)]
iter := ParseBytes(DEFAULT_CONFIG, data) iter := ParseBytes(ConfigOfDefault, data)
any := iter.ReadAny() any := iter.ReadAny()
if iter.head == iter.tail { if iter.head == iter.tail {
iter.loadMore() iter.loadMore()
@ -110,7 +110,7 @@ func UnmarshalAnyFromString(str string) (Any, error) {
// Marshal returns the JSON encoding of v, adapts to json/encoding Marshal API // Marshal returns the JSON encoding of v, adapts to json/encoding Marshal API
// Refer to https://godoc.org/encoding/json#Marshal for more information // Refer to https://godoc.org/encoding/json#Marshal for more information
func Marshal(v interface{}) ([]byte, error) { func Marshal(v interface{}) ([]byte, error) {
stream := NewStream(DEFAULT_CONFIG, nil, 256) stream := NewStream(ConfigOfDefault, nil, 256)
stream.WriteVal(v) stream.WriteVal(v)
if stream.Error != nil { if stream.Error != nil {
return nil, stream.Error return nil, stream.Error
@ -133,7 +133,7 @@ func MarshalToString(v interface{}) (string, error) {
// Instead of a json/encoding Decoder, an AdaptedDecoder is returned // Instead of a json/encoding Decoder, an AdaptedDecoder is returned
// Refer to https://godoc.org/encoding/json#NewDecoder for more information // Refer to https://godoc.org/encoding/json#NewDecoder for more information
func NewDecoder(reader io.Reader) *AdaptedDecoder { func NewDecoder(reader io.Reader) *AdaptedDecoder {
iter := Parse(DEFAULT_CONFIG, reader, 512) iter := Parse(ConfigOfDefault, reader, 512)
return &AdaptedDecoder{iter} return &AdaptedDecoder{iter}
} }

4
feature_any_array.go
View File

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

2
feature_any_float.go
View File

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

2
feature_any_int64.go
View File

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

4
feature_any_object.go
View File

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

2
feature_any_string.go
View File

@ -20,7 +20,7 @@ func (any *stringLazyAny) ValueType() ValueType {
func (any *stringLazyAny) Parse() *Iterator { func (any *stringLazyAny) Parse() *Iterator {
iter := any.iter iter := any.iter
if iter == nil { if iter == nil {
iter = NewIterator(DEFAULT_CONFIG) iter = NewIterator(ConfigOfDefault)
any.iter = iter any.iter = iter
} }
iter.ResetBytes(any.buf) 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 { func (any *uint64LazyAny) Parse() *Iterator {
iter := any.iter iter := any.iter
if iter == nil { if iter == nil {
iter = NewIterator(DEFAULT_CONFIG) iter = NewIterator(ConfigOfDefault)
} }
iter.ResetBytes(any.buf) iter.ResetBytes(any.buf)
return iter return iter

23
feature_config.go
View File

@ -11,6 +11,7 @@ type Config struct {
IndentionStep int IndentionStep int
MarshalFloatWith6Digits bool MarshalFloatWith6Digits bool
SupportUnexportedStructFields bool SupportUnexportedStructFields bool
EscapeHtml bool
} }
type frozenConfig struct { type frozenConfig struct {
@ -20,7 +21,12 @@ type frozenConfig struct {
extensions []ExtensionFunc extensions []ExtensionFunc
} }
var DEFAULT_CONFIG = Config{}.Froze() var ConfigOfDefault = Config{}.Froze()
// Trying to be 100% compatible with standard library behavior
var ConfigCompatibleWithStandardLibrary = Config{
EscapeHtml: true,
}.Froze()
func (cfg Config) Froze() *frozenConfig { func (cfg Config) Froze() *frozenConfig {
frozenConfig := &frozenConfig{ frozenConfig := &frozenConfig{
@ -34,16 +40,19 @@ func (cfg Config) Froze() *frozenConfig {
if cfg.SupportUnexportedStructFields { if cfg.SupportUnexportedStructFields {
frozenConfig.supportUnexportedStructFields() frozenConfig.supportUnexportedStructFields()
} }
if cfg.EscapeHtml {
frozenConfig.escapeHtml()
}
return frozenConfig return frozenConfig
} }
// RegisterExtension can register a custom extension // RegisterExtension can register a custom extension
func (cfg *frozenConfig) RegisterExtension(extension ExtensionFunc) { func (cfg *frozenConfig) registerExtension(extension ExtensionFunc) {
cfg.extensions = append(cfg.extensions, extension) cfg.extensions = append(cfg.extensions, extension)
} }
func (cfg *frozenConfig) supportUnexportedStructFields() { func (cfg *frozenConfig) supportUnexportedStructFields() {
cfg.RegisterExtension(func(type_ reflect.Type, field *reflect.StructField) ([]string, EncoderFunc, DecoderFunc) { cfg.registerExtension(func(type_ reflect.Type, field *reflect.StructField) ([]string, EncoderFunc, DecoderFunc) {
return []string{field.Name}, nil, nil return []string{field.Name}, nil, nil
}) })
} }
@ -62,6 +71,14 @@ func (cfg *frozenConfig) marshalFloatWith6Digits() {
}}) }})
} }
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) { func (cfg *frozenConfig) addDecoderToCache(cacheKey reflect.Type, decoder Decoder) {
done := false done := false
for !done { for !done {

58
feature_stream.go
View File

@ -197,64 +197,6 @@ func (b *Stream) WriteRaw(s string) {
b.n += n 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() { func (stream *Stream) WriteNil() {
stream.writeFourBytes('n', 'u', 'l', 'l') stream.writeFourBytes('n', 'u', 'l', 'l')
} }

367
feature_stream_string.go Normal file
View File

@ -0,0 +1,367 @@
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 > 31 && htmlSafeSet[c] {
stream.buf[n] = c
n++
} else {
break
}
}
if i == valLen {
stream.buf[n] = '"'
n++
stream.n = n
return
}
stream.n = n
start := 0
// for the remaining parts, we process them char by char
for ; i < valLen; i++ {
if b := s[i]; b < utf8.RuneSelf {
if htmlSafeSet[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('"')
}
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
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)
}
}
stream.writeByte('"')
}

22
jsoniter_array_test.go
View File

@ -10,10 +10,10 @@ import (
func Test_empty_array(t *testing.T) { func Test_empty_array(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, `[]`) iter := ParseString(ConfigOfDefault, `[]`)
cont := iter.ReadArray() cont := iter.ReadArray()
should.False(cont) should.False(cont)
iter = ParseString(DEFAULT_CONFIG, `[]`) iter = ParseString(ConfigOfDefault, `[]`)
iter.ReadArrayCB(func(iter *Iterator) bool { iter.ReadArrayCB(func(iter *Iterator) bool {
should.FailNow("should not call") should.FailNow("should not call")
return true return true
@ -22,11 +22,11 @@ func Test_empty_array(t *testing.T) {
func Test_one_element(t *testing.T) { func Test_one_element(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, `[1]`) iter := ParseString(ConfigOfDefault, `[1]`)
should.True(iter.ReadArray()) should.True(iter.ReadArray())
should.Equal(1, iter.ReadInt()) should.Equal(1, iter.ReadInt())
should.False(iter.ReadArray()) should.False(iter.ReadArray())
iter = ParseString(DEFAULT_CONFIG, `[1]`) iter = ParseString(ConfigOfDefault, `[1]`)
iter.ReadArrayCB(func(iter *Iterator) bool { iter.ReadArrayCB(func(iter *Iterator) bool {
should.Equal(1, iter.ReadInt()) should.Equal(1, iter.ReadInt())
return true return true
@ -35,13 +35,13 @@ func Test_one_element(t *testing.T) {
func Test_two_elements(t *testing.T) { func Test_two_elements(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, `[1,2]`) iter := ParseString(ConfigOfDefault, `[1,2]`)
should.True(iter.ReadArray()) should.True(iter.ReadArray())
should.Equal(int64(1), iter.ReadInt64()) should.Equal(int64(1), iter.ReadInt64())
should.True(iter.ReadArray()) should.True(iter.ReadArray())
should.Equal(int64(2), iter.ReadInt64()) should.Equal(int64(2), iter.ReadInt64())
should.False(iter.ReadArray()) should.False(iter.ReadArray())
iter = ParseString(DEFAULT_CONFIG, `[1,2]`) iter = ParseString(ConfigOfDefault, `[1,2]`)
should.Equal([]interface{}{float64(1), float64(2)}, iter.Read()) 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) { func Test_whitespace_in_head(t *testing.T) {
iter := ParseString(DEFAULT_CONFIG, ` [1]`) iter := ParseString(ConfigOfDefault, ` [1]`)
cont := iter.ReadArray() cont := iter.ReadArray()
if cont != true { if cont != true {
t.FailNow() t.FailNow()
@ -163,7 +163,7 @@ func Test_whitespace_in_head(t *testing.T) {
} }
func Test_whitespace_after_array_start(t *testing.T) { func Test_whitespace_after_array_start(t *testing.T) {
iter := ParseString(DEFAULT_CONFIG, `[ 1]`) iter := ParseString(ConfigOfDefault, `[ 1]`)
cont := iter.ReadArray() cont := iter.ReadArray()
if cont != true { if cont != true {
t.FailNow() t.FailNow()
@ -174,7 +174,7 @@ func Test_whitespace_after_array_start(t *testing.T) {
} }
func Test_whitespace_before_array_end(t *testing.T) { func Test_whitespace_before_array_end(t *testing.T) {
iter := ParseString(DEFAULT_CONFIG, `[1 ]`) iter := ParseString(ConfigOfDefault, `[1 ]`)
cont := iter.ReadArray() cont := iter.ReadArray()
if cont != true { if cont != true {
t.FailNow() t.FailNow()
@ -189,7 +189,7 @@ func Test_whitespace_before_array_end(t *testing.T) {
} }
func Test_whitespace_before_comma(t *testing.T) { func Test_whitespace_before_comma(t *testing.T) {
iter := ParseString(DEFAULT_CONFIG, `[1 ,2]`) iter := ParseString(ConfigOfDefault, `[1 ,2]`)
cont := iter.ReadArray() cont := iter.ReadArray()
if cont != true { if cont != true {
t.FailNow() t.FailNow()
@ -287,7 +287,7 @@ func Test_decode_byte_array(t *testing.T) {
func Benchmark_jsoniter_array(b *testing.B) { func Benchmark_jsoniter_array(b *testing.B) {
b.ReportAllocs() b.ReportAllocs()
input := []byte(`[1,2,3,4,5,6,7,8,9]`) input := []byte(`[1,2,3,4,5,6,7,8,9]`)
iter := ParseBytes(DEFAULT_CONFIG, input) iter := ParseBytes(ConfigOfDefault, input)
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
iter.ResetBytes(input) 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) { func Test_true(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, `true`) iter := ParseString(ConfigOfDefault, `true`)
should.True(iter.ReadBool()) should.True(iter.ReadBool())
iter = ParseString(DEFAULT_CONFIG, `true`) iter = ParseString(ConfigOfDefault, `true`)
should.Equal(true, iter.Read()) should.Equal(true, iter.Read())
} }
func Test_false(t *testing.T) { func Test_false(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, `false`) iter := ParseString(ConfigOfDefault, `false`)
should.False(iter.ReadBool()) 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) { func Test_write_true_false(t *testing.T) {
should := require.New(t) should := require.New(t)
buf := &bytes.Buffer{} buf := &bytes.Buffer{}
stream := NewStream(DEFAULT_CONFIG, buf, 4096) stream := NewStream(ConfigOfDefault, buf, 4096)
stream.WriteTrue() stream.WriteTrue()
stream.WriteFalse() stream.WriteFalse()
stream.Flush() stream.Flush()
@ -41,7 +41,7 @@ func Test_write_true_false(t *testing.T) {
func Test_write_val_bool(t *testing.T) { func Test_write_val_bool(t *testing.T) {
should := require.New(t) should := require.New(t)
buf := &bytes.Buffer{} buf := &bytes.Buffer{}
stream := NewStream(DEFAULT_CONFIG, buf, 4096) stream := NewStream(ConfigOfDefault, buf, 4096)
stream.WriteVal(true) stream.WriteVal(true)
stream.Flush() stream.Flush()
should.Nil(stream.Error) should.Nil(stream.Error)

10
jsoniter_customize_test.go
View File

@ -19,7 +19,7 @@ func Test_customize_type_decoder(t *testing.T) {
} }
*((*time.Time)(ptr)) = t *((*time.Time)(ptr)) = t
}) })
defer DEFAULT_CONFIG.CleanDecoders() defer ConfigOfDefault.CleanDecoders()
val := time.Time{} val := time.Time{}
err := Unmarshal([]byte(`"2016-12-05 08:43:28"`), &val) err := Unmarshal([]byte(`"2016-12-05 08:43:28"`), &val)
if err != nil { if err != nil {
@ -37,7 +37,7 @@ func Test_customize_type_encoder(t *testing.T) {
t := *((*time.Time)(ptr)) t := *((*time.Time)(ptr))
stream.WriteString(t.UTC().Format("2006-01-02 15:04:05")) stream.WriteString(t.UTC().Format("2006-01-02 15:04:05"))
}) })
defer DEFAULT_CONFIG.CleanEncoders() defer ConfigOfDefault.CleanEncoders()
val := time.Unix(0, 0) val := time.Unix(0, 0)
str, err := MarshalToString(val) str, err := MarshalToString(val)
should.Nil(err) should.Nil(err)
@ -45,13 +45,13 @@ func Test_customize_type_encoder(t *testing.T) {
} }
func Test_customize_byte_array_encoder(t *testing.T) { func Test_customize_byte_array_encoder(t *testing.T) {
DEFAULT_CONFIG.CleanEncoders() ConfigOfDefault.CleanEncoders()
should := require.New(t) should := require.New(t)
RegisterTypeEncoder("[]uint8", func(ptr unsafe.Pointer, stream *Stream) { RegisterTypeEncoder("[]uint8", func(ptr unsafe.Pointer, stream *Stream) {
t := *((*[]byte)(ptr)) t := *((*[]byte)(ptr))
stream.WriteString(string(t)) stream.WriteString(string(t))
}) })
defer DEFAULT_CONFIG.CleanEncoders() defer ConfigOfDefault.CleanEncoders()
val := []byte("abc") val := []byte("abc")
str, err := MarshalToString(val) str, err := MarshalToString(val)
should.Nil(err) should.Nil(err)
@ -74,7 +74,7 @@ func Test_customize_field_decoder(t *testing.T) {
RegisterFieldDecoder("jsoniter.Tom", "field1", func(ptr unsafe.Pointer, iter *Iterator) { RegisterFieldDecoder("jsoniter.Tom", "field1", func(ptr unsafe.Pointer, iter *Iterator) {
*((*string)(ptr)) = strconv.Itoa(iter.ReadInt()) *((*string)(ptr)) = strconv.Itoa(iter.ReadInt())
}) })
defer DEFAULT_CONFIG.CleanDecoders() defer ConfigOfDefault.CleanDecoders()
tom := Tom{} tom := Tom{}
err := Unmarshal([]byte(`{"field1": 100}`), &tom) err := Unmarshal([]byte(`{"field1": 100}`), &tom)
if err != nil { if err != nil {

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) { func Test_iterator_api_demo(t *testing.T) {
iter := ParseString(DEFAULT_CONFIG, `[0,1,2,3]`) iter := ParseString(ConfigOfDefault, `[0,1,2,3]`)
total := 0 total := 0
for iter.ReadArray() { for iter.ReadArray() {
total += iter.ReadInt() total += iter.ReadInt()

38
jsoniter_find_end_test.go
View File

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

30
jsoniter_float_test.go
View File

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

74
jsoniter_int_test.go
View File

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

4
jsoniter_interface_test.go
View File

@ -141,8 +141,8 @@ func Test_encode_object_contain_non_empty_interface(t *testing.T) {
} }
func Test_nil_non_empty_interface(t *testing.T) { func Test_nil_non_empty_interface(t *testing.T) {
DEFAULT_CONFIG.CleanEncoders() ConfigOfDefault.CleanEncoders()
DEFAULT_CONFIG.CleanDecoders() ConfigOfDefault.CleanDecoders()
type TestObject struct { type TestObject struct {
Field []MyInterface Field []MyInterface
} }

6
jsoniter_io_test.go
View File

@ -7,7 +7,7 @@ import (
) )
func Test_read_by_one(t *testing.T) { func Test_read_by_one(t *testing.T) {
iter := Parse(DEFAULT_CONFIG, bytes.NewBufferString("abc"), 1) iter := Parse(ConfigOfDefault, bytes.NewBufferString("abc"), 1)
b := iter.readByte() b := iter.readByte()
if iter.Error != nil { if iter.Error != nil {
t.Fatal(iter.Error) t.Fatal(iter.Error)
@ -34,7 +34,7 @@ func Test_read_by_one(t *testing.T) {
} }
func Test_read_by_two(t *testing.T) { func Test_read_by_two(t *testing.T) {
iter := Parse(DEFAULT_CONFIG, bytes.NewBufferString("abc"), 2) iter := Parse(ConfigOfDefault, bytes.NewBufferString("abc"), 2)
b := iter.readByte() b := iter.readByte()
if iter.Error != nil { if iter.Error != nil {
t.Fatal(iter.Error) t.Fatal(iter.Error)
@ -67,7 +67,7 @@ func Test_read_by_two(t *testing.T) {
} }
func Test_read_until_eof(t *testing.T) { func Test_read_until_eof(t *testing.T) {
iter := Parse(DEFAULT_CONFIG, bytes.NewBufferString("abc"), 2) iter := Parse(ConfigOfDefault, bytes.NewBufferString("abc"), 2)
iter.readByte() iter.readByte()
iter.readByte() iter.readByte()
b := 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() b.ReportAllocs()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
file, _ := os.Open("/tmp/large-file.json") file, _ := os.Open("/tmp/large-file.json")
iter := Parse(DEFAULT_CONFIG, file, 4096) iter := Parse(ConfigOfDefault, file, 4096)
count := 0 count := 0
for iter.ReadArray() { for iter.ReadArray() {
iter.Skip() iter.Skip()

6
jsoniter_map_test.go
View File

@ -9,7 +9,7 @@ import (
func Test_read_map(t *testing.T) { func Test_read_map(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, `{"hello": "world"}`) iter := ParseString(ConfigOfDefault, `{"hello": "world"}`)
m := map[string]string{"1": "2"} m := map[string]string{"1": "2"}
iter.ReadVal(&m) iter.ReadVal(&m)
copy(iter.buf, []byte{0, 0, 0, 0, 0, 0}) 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) { func Test_read_map_of_interface(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, `{"hello": "world"}`) iter := ParseString(ConfigOfDefault, `{"hello": "world"}`)
m := map[string]interface{}{"1": "2"} m := map[string]interface{}{"1": "2"}
iter.ReadVal(&m) iter.ReadVal(&m)
should.Equal(map[string]interface{}{"1": "2", "hello": "world"}, m) should.Equal(map[string]interface{}{"1": "2", "hello": "world"}, m)
iter = ParseString(DEFAULT_CONFIG, `{"hello": "world"}`) iter = ParseString(ConfigOfDefault, `{"hello": "world"}`)
should.Equal(map[string]interface{}{"hello": "world"}, iter.Read()) should.Equal(map[string]interface{}{"hello": "world"}, iter.Read())
} }

4
jsoniter_nested_test.go
View File

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

16
jsoniter_null_test.go
View File

@ -9,11 +9,11 @@ import (
func Test_read_null(t *testing.T) { func Test_read_null(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, `null`) iter := ParseString(ConfigOfDefault, `null`)
should.True(iter.ReadNil()) should.True(iter.ReadNil())
iter = ParseString(DEFAULT_CONFIG, `null`) iter = ParseString(ConfigOfDefault, `null`)
should.Nil(iter.Read()) should.Nil(iter.Read())
iter = ParseString(DEFAULT_CONFIG, `null`) iter = ParseString(ConfigOfDefault, `null`)
any, err := UnmarshalAnyFromString(`null`) any, err := UnmarshalAnyFromString(`null`)
should.Nil(err) should.Nil(err)
should.Equal(0, any.ToInt()) should.Equal(0, any.ToInt())
@ -25,7 +25,7 @@ func Test_read_null(t *testing.T) {
func Test_write_null(t *testing.T) { func Test_write_null(t *testing.T) {
should := require.New(t) should := require.New(t)
buf := &bytes.Buffer{} buf := &bytes.Buffer{}
stream := NewStream(DEFAULT_CONFIG, buf, 4096) stream := NewStream(ConfigOfDefault, buf, 4096)
stream.WriteNil() stream.WriteNil()
stream.Flush() stream.Flush()
should.Nil(stream.Error) should.Nil(stream.Error)
@ -41,7 +41,7 @@ func Test_encode_null(t *testing.T) {
func Test_decode_null_object(t *testing.T) { func Test_decode_null_object(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, `[null,"a"]`) iter := ParseString(ConfigOfDefault, `[null,"a"]`)
iter.ReadArray() iter.ReadArray()
if iter.ReadObject() != "" { if iter.ReadObject() != "" {
t.FailNow() t.FailNow()
@ -59,7 +59,7 @@ func Test_decode_null_object(t *testing.T) {
} }
func Test_decode_null_array(t *testing.T) { func Test_decode_null_array(t *testing.T) {
iter := ParseString(DEFAULT_CONFIG, `[null,"a"]`) iter := ParseString(ConfigOfDefault, `[null,"a"]`)
iter.ReadArray() iter.ReadArray()
if iter.ReadArray() != false { if iter.ReadArray() != false {
t.FailNow() t.FailNow()
@ -72,7 +72,7 @@ func Test_decode_null_array(t *testing.T) {
func Test_decode_null_string(t *testing.T) { func Test_decode_null_string(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, `[null,"a"]`) iter := ParseString(ConfigOfDefault, `[null,"a"]`)
should.True(iter.ReadArray()) should.True(iter.ReadArray())
should.Equal("", iter.ReadString()) should.Equal("", iter.ReadString())
should.True(iter.ReadArray()) should.True(iter.ReadArray())
@ -80,7 +80,7 @@ func Test_decode_null_string(t *testing.T) {
} }
func Test_decode_null_skip(t *testing.T) { func Test_decode_null_skip(t *testing.T) {
iter := ParseString(DEFAULT_CONFIG, `[null,"a"]`) iter := ParseString(ConfigOfDefault, `[null,"a"]`)
iter.ReadArray() iter.ReadArray()
iter.Skip() iter.Skip()
iter.ReadArray() iter.ReadArray()

14
jsoniter_object_test.go
View File

@ -9,10 +9,10 @@ import (
func Test_empty_object(t *testing.T) { func Test_empty_object(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, `{}`) iter := ParseString(ConfigOfDefault, `{}`)
field := iter.ReadObject() field := iter.ReadObject()
should.Equal("", field) should.Equal("", field)
iter = ParseString(DEFAULT_CONFIG, `{}`) iter = ParseString(ConfigOfDefault, `{}`)
iter.ReadObjectCB(func(iter *Iterator, field string) bool { iter.ReadObjectCB(func(iter *Iterator, field string) bool {
should.FailNow("should not call") should.FailNow("should not call")
return true return true
@ -21,14 +21,14 @@ func Test_empty_object(t *testing.T) {
func Test_one_field(t *testing.T) { func Test_one_field(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, `{"a": "b"}`) iter := ParseString(ConfigOfDefault, `{"a": "b"}`)
field := iter.ReadObject() field := iter.ReadObject()
should.Equal("a", field) should.Equal("a", field)
value := iter.ReadString() value := iter.ReadString()
should.Equal("b", value) should.Equal("b", value)
field = iter.ReadObject() field = iter.ReadObject()
should.Equal("", field) should.Equal("", field)
iter = ParseString(DEFAULT_CONFIG, `{"a": "b"}`) iter = ParseString(ConfigOfDefault, `{"a": "b"}`)
should.True(iter.ReadObjectCB(func(iter *Iterator, field string) bool { should.True(iter.ReadObjectCB(func(iter *Iterator, field string) bool {
should.Equal("a", field) should.Equal("a", field)
return true return true
@ -37,7 +37,7 @@ func Test_one_field(t *testing.T) {
func Test_two_field(t *testing.T) { func Test_two_field(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, `{ "a": "b" , "c": "d" }`) iter := ParseString(ConfigOfDefault, `{ "a": "b" , "c": "d" }`)
field := iter.ReadObject() field := iter.ReadObject()
should.Equal("a", field) should.Equal("a", field)
value := iter.ReadString() value := iter.ReadString()
@ -48,7 +48,7 @@ func Test_two_field(t *testing.T) {
should.Equal("d", value) should.Equal("d", value)
field = iter.ReadObject() field = iter.ReadObject()
should.Equal("", field) should.Equal("", field)
iter = ParseString(DEFAULT_CONFIG, `{"field1": "1", "field2": 2}`) iter = ParseString(ConfigOfDefault, `{"field1": "1", "field2": 2}`)
for field := iter.ReadObject(); field != ""; field = iter.ReadObject() { for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
switch field { switch field {
case "field1": case "field1":
@ -229,7 +229,7 @@ func Benchmark_jsoniter_object(b *testing.B) {
Field2 uint64 Field2 uint64
} }
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
iter := ParseString(DEFAULT_CONFIG, `{"field1": "1", "field2": 2}`) iter := ParseString(ConfigOfDefault, `{"field1": "1", "field2": 2}`)
obj := TestObj{} obj := TestObj{}
for field := iter.ReadObject(); field != ""; field = iter.ReadObject() { for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
switch field { switch field {

32
jsoniter_reflect_native_test.go
View File

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

10
jsoniter_reflect_test.go
View File

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

16
jsoniter_skip_test.go
View File

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

8
jsoniter_stream_test.go
View File

@ -7,7 +7,7 @@ import (
func Test_writeByte_should_grow_buffer(t *testing.T) { func Test_writeByte_should_grow_buffer(t *testing.T) {
should := require.New(t) should := require.New(t)
stream := NewStream(DEFAULT_CONFIG, nil, 1) stream := NewStream(ConfigOfDefault, nil, 1)
stream.writeByte('1') stream.writeByte('1')
should.Equal("1", string(stream.Buffer())) should.Equal("1", string(stream.Buffer()))
should.Equal(1, len(stream.buf)) 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) { func Test_writeBytes_should_grow_buffer(t *testing.T) {
should := require.New(t) should := require.New(t)
stream := NewStream(DEFAULT_CONFIG, nil, 1) stream := NewStream(ConfigOfDefault, nil, 1)
stream.Write([]byte{'1', '2'}) stream.Write([]byte{'1', '2'})
should.Equal("12", string(stream.Buffer())) should.Equal("12", string(stream.Buffer()))
should.Equal(3, len(stream.buf)) should.Equal(3, len(stream.buf))
@ -38,7 +38,7 @@ func Test_writeIndention_should_grow_buffer(t *testing.T) {
func Test_writeRaw_should_grow_buffer(t *testing.T) { func Test_writeRaw_should_grow_buffer(t *testing.T) {
should := require.New(t) should := require.New(t)
stream := NewStream(DEFAULT_CONFIG, nil, 1) stream := NewStream(ConfigOfDefault, nil, 1)
stream.WriteRaw("123") stream.WriteRaw("123")
should.Nil(stream.Error) should.Nil(stream.Error)
should.Equal("123", string(stream.Buffer())) should.Equal("123", string(stream.Buffer()))
@ -46,7 +46,7 @@ func Test_writeRaw_should_grow_buffer(t *testing.T) {
func Test_writeString_should_grow_buffer(t *testing.T) { func Test_writeString_should_grow_buffer(t *testing.T) {
should := require.New(t) should := require.New(t)
stream := NewStream(DEFAULT_CONFIG, nil, 0) stream := NewStream(ConfigOfDefault, nil, 0)
stream.WriteString("123") stream.WriteString("123")
should.Nil(stream.Error) should.Nil(stream.Error)
should.Equal(`"123"`, string(stream.Buffer())) should.Equal(`"123"`, string(stream.Buffer()))

55
jsoniter_string_test.go
View File

@ -6,6 +6,7 @@ import (
"fmt" "fmt"
"github.com/json-iterator/go/require" "github.com/json-iterator/go/require"
"testing" "testing"
"unicode/utf8"
) )
func Test_read_normal_string(t *testing.T) { func Test_read_normal_string(t *testing.T) {
@ -17,22 +18,22 @@ func Test_read_normal_string(t *testing.T) {
for input, output := range cases { for input, output := range cases {
t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) { t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, input) iter := ParseString(ConfigOfDefault, input)
should.Equal(output, iter.ReadString()) should.Equal(output, iter.ReadString())
}) })
t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) { t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := Parse(DEFAULT_CONFIG, bytes.NewBufferString(input), 2) iter := Parse(ConfigOfDefault, bytes.NewBufferString(input), 2)
should.Equal(output, iter.ReadString()) should.Equal(output, iter.ReadString())
}) })
t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) { t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, input) iter := ParseString(ConfigOfDefault, input)
should.Equal(output, string(iter.ReadStringAsSlice())) should.Equal(output, string(iter.ReadStringAsSlice()))
}) })
t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) { t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := Parse(DEFAULT_CONFIG, bytes.NewBufferString(input), 2) iter := Parse(ConfigOfDefault, bytes.NewBufferString(input), 2)
should.Equal(output, string(iter.ReadStringAsSlice())) should.Equal(output, string(iter.ReadStringAsSlice()))
}) })
} }
@ -48,12 +49,12 @@ func Test_read_exotic_string(t *testing.T) {
for input, output := range cases { for input, output := range cases {
t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) { t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, input) iter := ParseString(ConfigOfDefault, input)
should.Equal(output, iter.ReadString()) should.Equal(output, iter.ReadString())
}) })
t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) { t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := Parse(DEFAULT_CONFIG, bytes.NewBufferString(input), 2) iter := Parse(ConfigOfDefault, bytes.NewBufferString(input), 2)
should.Equal(output, iter.ReadString()) should.Equal(output, iter.ReadString())
}) })
} }
@ -61,7 +62,7 @@ func Test_read_exotic_string(t *testing.T) {
func Test_read_string_as_interface(t *testing.T) { func Test_read_string_as_interface(t *testing.T) {
should := require.New(t) should := require.New(t)
iter := ParseString(DEFAULT_CONFIG, `"hello"`) iter := ParseString(ConfigOfDefault, `"hello"`)
should.Equal("hello", iter.Read()) should.Equal("hello", iter.Read())
} }
@ -98,7 +99,7 @@ func Test_write_string(t *testing.T) {
func Test_write_val_string(t *testing.T) { func Test_write_val_string(t *testing.T) {
should := require.New(t) should := require.New(t)
buf := &bytes.Buffer{} buf := &bytes.Buffer{}
stream := NewStream(DEFAULT_CONFIG, buf, 4096) stream := NewStream(ConfigOfDefault, buf, 4096)
stream.WriteVal("hello") stream.WriteVal("hello")
stream.Flush() stream.Flush()
should.Nil(stream.Error) should.Nil(stream.Error)
@ -112,25 +113,39 @@ func Test_decode_slash(t *testing.T) {
should.NotNil(UnmarshalFromString("\\", &obj)) should.NotNil(UnmarshalFromString("\\", &obj))
} }
//func Test_html_escape(t *testing.T) { func Test_html_escape(t *testing.T) {
// should := require.New(t) should := require.New(t)
// output, err := json.Marshal(`>`) output, err := json.Marshal(`>`)
// should.Nil(err) should.Nil(err)
// should.Equal(`"\u003e"`, string(output)) should.Equal(`"\u003e"`, string(output))
// output, err = Marshal(`>`) output, err = ConfigCompatibleWithStandardLibrary.Marshal(`>`)
// should.Nil(err) should.Nil(err)
// should.Equal(`"\u003e"`, string(output)) 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 Benchmark_jsoniter_unicode(b *testing.B) { func Benchmark_jsoniter_unicode(b *testing.B) {
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
iter := ParseString(DEFAULT_CONFIG, `"\ud83d\udc4a"`) iter := ParseString(ConfigOfDefault, `"\ud83d\udc4a"`)
iter.ReadString() iter.ReadString()
} }
} }
func Benchmark_jsoniter_ascii(b *testing.B) { func Benchmark_jsoniter_ascii(b *testing.B) {
iter := NewIterator(DEFAULT_CONFIG) iter := NewIterator(ConfigOfDefault)
input := []byte(`"hello, world! hello, world!"`) input := []byte(`"hello, world! hello, world!"`)
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
@ -140,7 +155,7 @@ func Benchmark_jsoniter_ascii(b *testing.B) {
} }
func Benchmark_jsoniter_string_as_bytes(b *testing.B) { func Benchmark_jsoniter_string_as_bytes(b *testing.B) {
iter := ParseString(DEFAULT_CONFIG, `"hello, world!"`) iter := ParseString(ConfigOfDefault, `"hello, world!"`)
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
iter.ResetBytes(iter.buf) iter.ResetBytes(iter.buf)