633 lines
18 KiB
Cheetah
633 lines
18 KiB
Cheetah
// Code generated by Makefile, DO NOT EDIT.
|
|
|
|
/*
|
|
* Copyright 2021 ByteDance Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package {{PACKAGE}}
|
|
|
|
import (
|
|
`encoding/hex`
|
|
`fmt`
|
|
`math`
|
|
`strings`
|
|
`testing`
|
|
`unsafe`
|
|
|
|
`github.com/bytedance/sonic/internal/native/types`
|
|
`github.com/bytedance/sonic/internal/rt`
|
|
`github.com/davecgh/go-spew/spew`
|
|
`github.com/stretchr/testify/assert`
|
|
`github.com/stretchr/testify/require`
|
|
)
|
|
|
|
func TestNative_Value(t *testing.T) {
|
|
var v types.JsonState
|
|
s := ` -12345`
|
|
p := (*rt.GoString)(unsafe.Pointer(&s))
|
|
x := value(p.Ptr, p.Len, 0, &v, 0)
|
|
assert.Equal(t, 9, x)
|
|
assert.Equal(t, types.V_INTEGER, v.Vt)
|
|
assert.Equal(t, int64(-12345), v.Iv)
|
|
assert.Equal(t, 3, v.Ep)
|
|
}
|
|
|
|
func TestNative_Value_OutOfBound(t *testing.T) {
|
|
var v types.JsonState
|
|
mem := []byte{'"', '"'}
|
|
s := rt.Mem2Str(mem[:1])
|
|
p := (*rt.GoString)(unsafe.Pointer(&s))
|
|
x := value(p.Ptr, p.Len, 0, &v, 0)
|
|
assert.Equal(t, 1, x)
|
|
assert.Equal(t, -int(types.ERR_EOF), int(v.Vt))
|
|
}
|
|
|
|
func TestNative_Quote(t *testing.T) {
|
|
s := "hello\b\f\n\r\t\\\"\u666fworld"
|
|
d := make([]byte, 256)
|
|
dp := (*rt.GoSlice)(unsafe.Pointer(&d))
|
|
sp := (*rt.GoString)(unsafe.Pointer(&s))
|
|
rv := quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, 0)
|
|
if rv < 0 {
|
|
require.NoError(t, types.ParsingError(-rv))
|
|
}
|
|
assert.Equal(t, len(s), rv)
|
|
assert.Equal(t, 35, len(d))
|
|
assert.Equal(t, `hello\u0008\u000c\n\r\t\\\"景world`, string(d))
|
|
}
|
|
|
|
func TestNative_QuoteNoMem(t *testing.T) {
|
|
s := "hello\b\f\n\r\t\\\"\u666fworld"
|
|
d := make([]byte, 10)
|
|
dp := (*rt.GoSlice)(unsafe.Pointer(&d))
|
|
sp := (*rt.GoString)(unsafe.Pointer(&s))
|
|
rv := quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, 0)
|
|
assert.Equal(t, -6, rv)
|
|
assert.Equal(t, 5, len(d))
|
|
assert.Equal(t, `hello`, string(d))
|
|
}
|
|
|
|
func TestNative_DoubleQuote(t *testing.T) {
|
|
s := "hello\b\f\n\r\t\\\"\u666fworld"
|
|
d := make([]byte, 256)
|
|
dp := (*rt.GoSlice)(unsafe.Pointer(&d))
|
|
sp := (*rt.GoString)(unsafe.Pointer(&s))
|
|
rv := quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, types.F_DOUBLE_UNQUOTE)
|
|
if rv < 0 {
|
|
require.NoError(t, types.ParsingError(-rv))
|
|
}
|
|
assert.Equal(t, len(s), rv)
|
|
assert.Equal(t, 44, len(d))
|
|
assert.Equal(t, `hello\\u0008\\u000c\\n\\r\\t\\\\\\\"景world`, string(d))
|
|
}
|
|
|
|
func TestNative_Unquote(t *testing.T) {
|
|
s := `hello\b\f\n\r\t\\\"\u2333world`
|
|
d := make([]byte, 0, len(s))
|
|
ep := -1
|
|
dp := (*rt.GoSlice)(unsafe.Pointer(&d))
|
|
sp := (*rt.GoString)(unsafe.Pointer(&s))
|
|
rv := unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
|
|
if rv < 0 {
|
|
require.NoError(t, types.ParsingError(-rv))
|
|
}
|
|
dp.Len = rv
|
|
assert.Equal(t, -1, ep)
|
|
assert.Equal(t, "hello\b\f\n\r\t\\\"\u2333world", string(d))
|
|
}
|
|
|
|
func TestNative_UnquoteError(t *testing.T) {
|
|
s := `asdf\`
|
|
d := make([]byte, 0, len(s))
|
|
ep := -1
|
|
dp := (*rt.GoSlice)(unsafe.Pointer(&d))
|
|
sp := (*rt.GoString)(unsafe.Pointer(&s))
|
|
rv := unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
|
|
assert.Equal(t, -int(types.ERR_EOF), rv)
|
|
assert.Equal(t, 5, ep)
|
|
s = `asdf\gqwer`
|
|
d = make([]byte, 0, len(s))
|
|
ep = -1
|
|
dp = (*rt.GoSlice)(unsafe.Pointer(&d))
|
|
sp = (*rt.GoString)(unsafe.Pointer(&s))
|
|
rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
|
|
assert.Equal(t, -int(types.ERR_INVALID_ESCAPE), rv)
|
|
assert.Equal(t, 5, ep)
|
|
s = `asdf\u1gggqwer`
|
|
d = make([]byte, 0, len(s))
|
|
ep = -1
|
|
dp = (*rt.GoSlice)(unsafe.Pointer(&d))
|
|
sp = (*rt.GoString)(unsafe.Pointer(&s))
|
|
rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
|
|
assert.Equal(t, -int(types.ERR_INVALID_CHAR), rv)
|
|
assert.Equal(t, 7, ep)
|
|
s = `asdf\ud800qwer`
|
|
d = make([]byte, 0, len(s))
|
|
ep = -1
|
|
dp = (*rt.GoSlice)(unsafe.Pointer(&d))
|
|
sp = (*rt.GoString)(unsafe.Pointer(&s))
|
|
rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
|
|
assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
|
|
assert.Equal(t, 6, ep)
|
|
s = `asdf\\ud800qwer`
|
|
d = make([]byte, 0, len(s))
|
|
ep = -1
|
|
dp = (*rt.GoSlice)(unsafe.Pointer(&d))
|
|
sp = (*rt.GoString)(unsafe.Pointer(&s))
|
|
rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
|
|
assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
|
|
assert.Equal(t, 7, ep)
|
|
s = `asdf\ud800\ud800qwer`
|
|
d = make([]byte, 0, len(s))
|
|
ep = -1
|
|
dp = (*rt.GoSlice)(unsafe.Pointer(&d))
|
|
sp = (*rt.GoString)(unsafe.Pointer(&s))
|
|
rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
|
|
assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
|
|
assert.Equal(t, 12, ep)
|
|
s = `asdf\\ud800\\ud800qwer`
|
|
d = make([]byte, 0, len(s))
|
|
ep = -1
|
|
dp = (*rt.GoSlice)(unsafe.Pointer(&d))
|
|
sp = (*rt.GoString)(unsafe.Pointer(&s))
|
|
rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
|
|
assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
|
|
assert.Equal(t, 14, ep)
|
|
}
|
|
|
|
func TestNative_DoubleUnquote(t *testing.T) {
|
|
s := `hello\\b\\f\\n\\r\\t\\\\\\\"\\u2333world`
|
|
d := make([]byte, 0, len(s))
|
|
ep := -1
|
|
dp := (*rt.GoSlice)(unsafe.Pointer(&d))
|
|
sp := (*rt.GoString)(unsafe.Pointer(&s))
|
|
rv := unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
|
|
if rv < 0 {
|
|
require.NoError(t, types.ParsingError(-rv))
|
|
}
|
|
dp.Len = rv
|
|
assert.Equal(t, -1, ep)
|
|
assert.Equal(t, "hello\b\f\n\r\t\\\"\u2333world", string(d))
|
|
}
|
|
|
|
func TestNative_UnquoteUnicodeReplacement(t *testing.T) {
|
|
s := `hello\ud800world`
|
|
d := make([]byte, 0, len(s))
|
|
ep := -1
|
|
dp := (*rt.GoSlice)(unsafe.Pointer(&d))
|
|
sp := (*rt.GoString)(unsafe.Pointer(&s))
|
|
rv := unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_UNICODE_REPLACE)
|
|
if rv < 0 {
|
|
require.NoError(t, types.ParsingError(-rv))
|
|
}
|
|
dp.Len = rv
|
|
assert.Equal(t, -1, ep)
|
|
assert.Equal(t, "hello\ufffdworld", string(d))
|
|
s = `hello\ud800\ud800world`
|
|
d = make([]byte, 0, len(s))
|
|
ep = -1
|
|
dp = (*rt.GoSlice)(unsafe.Pointer(&d))
|
|
sp = (*rt.GoString)(unsafe.Pointer(&s))
|
|
rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_UNICODE_REPLACE)
|
|
if rv < 0 {
|
|
require.NoError(t, types.ParsingError(-rv))
|
|
}
|
|
dp.Len = rv
|
|
assert.Equal(t, -1, ep)
|
|
assert.Equal(t, "hello\ufffd\ufffdworld", string(d))
|
|
}
|
|
|
|
func TestNative_HTMLEscape(t *testing.T) {
|
|
s := "hello\u2029\u2028<&>world"
|
|
d := make([]byte, 256)
|
|
dp := (*rt.GoSlice)(unsafe.Pointer(&d))
|
|
sp := (*rt.GoString)(unsafe.Pointer(&s))
|
|
rv := html_escape(sp.Ptr, sp.Len, dp.Ptr, &dp.Len)
|
|
if rv < 0 {
|
|
require.NoError(t, types.ParsingError(-rv))
|
|
}
|
|
assert.Equal(t, len(s), rv)
|
|
assert.Equal(t, 40, len(d))
|
|
assert.Equal(t, `hello\u2029\u2028\u003c\u0026\u003eworld`, string(d))
|
|
}
|
|
|
|
func TestNative_HTMLEscapeNoMem(t *testing.T) {
|
|
s := "hello\u2029\u2028<&>world"
|
|
d := make([]byte, 10)
|
|
dp := (*rt.GoSlice)(unsafe.Pointer(&d))
|
|
sp := (*rt.GoString)(unsafe.Pointer(&s))
|
|
rv := html_escape(sp.Ptr, sp.Len, dp.Ptr, &dp.Len)
|
|
assert.Equal(t, -6, rv)
|
|
assert.Equal(t, 5, len(d))
|
|
assert.Equal(t, `hello`, string(d))
|
|
}
|
|
|
|
func TestNative_Vstring(t *testing.T) {
|
|
var v types.JsonState
|
|
i := 0
|
|
s := `test"test\n2"`
|
|
vstring(&s, &i, &v, 0)
|
|
assert.Equal(t, 5, i)
|
|
assert.Equal(t, -1, v.Ep)
|
|
assert.Equal(t, int64(0), v.Iv)
|
|
vstring(&s, &i, &v, 0)
|
|
assert.Equal(t, 13, i)
|
|
assert.Equal(t, 9, v.Ep)
|
|
assert.Equal(t, int64(5), v.Iv)
|
|
}
|
|
|
|
func TestNative_Vstring_ValidUnescapedChars(t *testing.T) {
|
|
var v types.JsonState
|
|
valid := uint64(types.F_VALIDATE_STRING)
|
|
i := 0
|
|
s := "test\x1f\""
|
|
vstring(&s, &i, &v, valid)
|
|
assert.Equal(t, -int(types.ERR_INVALID_CHAR), int(v.Vt))
|
|
}
|
|
|
|
func TestNative_VstringEscapeEOF(t *testing.T) {
|
|
var v types.JsonState
|
|
i := 0
|
|
s := `xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"x`
|
|
vstring(&s, &i, &v, 0)
|
|
assert.Equal(t, 95, i)
|
|
assert.Equal(t, 63, v.Ep)
|
|
assert.Equal(t, int64(0), v.Iv)
|
|
}
|
|
|
|
func TestNative_VstringHangUpOnRandomData(t *testing.T) {
|
|
v, e := hex.DecodeString(
|
|
"228dc61efd54ef80a908fb6026b7f2d5f92a257ba8b347c995f259eb8685376a" +
|
|
"8c4500262d9c308b3f3ec2577689cf345d9f86f9b5d18d3e463bec5c22df2d2e" +
|
|
"4506010eba1dae7278",
|
|
)
|
|
assert.Nil(t, e)
|
|
p := 1
|
|
s := rt.Mem2Str(v)
|
|
var js types.JsonState
|
|
vstring(&s, &p, &js, 0)
|
|
fmt.Printf("js: %s\n", spew.Sdump(js))
|
|
}
|
|
|
|
func TestNative_Vnumber(t *testing.T) {
|
|
var v types.JsonState
|
|
i := 0
|
|
s := "1234"
|
|
vnumber(&s, &i, &v)
|
|
assert.Equal(t, 4, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, int64(1234), v.Iv)
|
|
assert.Equal(t, types.V_INTEGER, v.Vt)
|
|
i = 0
|
|
s = "1.234"
|
|
vnumber(&s, &i, &v)
|
|
assert.Equal(t, 5, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, 1.234, v.Dv)
|
|
assert.Equal(t, types.V_DOUBLE, v.Vt)
|
|
i = 0
|
|
s = "1.234e5"
|
|
vnumber(&s, &i, &v)
|
|
assert.Equal(t, 7, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, 1.234e5, v.Dv)
|
|
assert.Equal(t, types.V_DOUBLE, v.Vt)
|
|
i = 0
|
|
s = "0.0125"
|
|
vnumber(&s, &i, &v)
|
|
assert.Equal(t, 6, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, 0.0125, v.Dv)
|
|
assert.Equal(t, types.V_DOUBLE, v.Vt)
|
|
i = 0
|
|
s = "100000000000000000000"
|
|
vnumber(&s, &i, &v)
|
|
assert.Equal(t, 21, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, 100000000000000000000.0, v.Dv)
|
|
assert.Equal(t, types.V_DOUBLE, v.Vt)
|
|
i = 0
|
|
s = "999999999999999900000"
|
|
vnumber(&s, &i, &v)
|
|
assert.Equal(t, 21, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, 999999999999999900000.0, v.Dv)
|
|
assert.Equal(t, types.V_DOUBLE, v.Vt)
|
|
i = 0
|
|
s = "-1.234"
|
|
vnumber(&s, &i, &v)
|
|
assert.Equal(t, 6, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, -1.234, v.Dv)
|
|
assert.Equal(t, types.V_DOUBLE, v.Vt)
|
|
}
|
|
|
|
func TestNative_Vsigned(t *testing.T) {
|
|
var v types.JsonState
|
|
i := 0
|
|
s := "1234"
|
|
vsigned(&s, &i, &v)
|
|
assert.Equal(t, 4, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, int64(1234), v.Iv)
|
|
assert.Equal(t, types.V_INTEGER, v.Vt)
|
|
i = 0
|
|
s = "-1234"
|
|
vsigned(&s, &i, &v)
|
|
assert.Equal(t, 5, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, int64(-1234), v.Iv)
|
|
assert.Equal(t, types.V_INTEGER, v.Vt)
|
|
i = 0
|
|
s = "9223372036854775807"
|
|
vsigned(&s, &i, &v)
|
|
assert.Equal(t, 19, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, int64(math.MaxInt64), v.Iv)
|
|
assert.Equal(t, types.V_INTEGER, v.Vt)
|
|
i = 0
|
|
s = "-9223372036854775808"
|
|
vsigned(&s, &i, &v)
|
|
assert.Equal(t, 20, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, int64(math.MinInt64), v.Iv)
|
|
assert.Equal(t, types.V_INTEGER, v.Vt)
|
|
i = 0
|
|
s = "9223372036854775808"
|
|
vsigned(&s, &i, &v)
|
|
assert.Equal(t, 18, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt)
|
|
i = 0
|
|
s = "-9223372036854775809"
|
|
vsigned(&s, &i, &v)
|
|
assert.Equal(t, 19, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt)
|
|
i = 0
|
|
s = "1.234"
|
|
vsigned(&s, &i, &v)
|
|
assert.Equal(t, 1, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
|
|
i = 0
|
|
s = "0.0125"
|
|
vsigned(&s, &i, &v)
|
|
assert.Equal(t, 1, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
|
|
i = 0
|
|
s = "-1234e5"
|
|
vsigned(&s, &i, &v)
|
|
assert.Equal(t, 5, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
|
|
i = 0
|
|
s = "-1234e-5"
|
|
vsigned(&s, &i, &v)
|
|
assert.Equal(t, 5, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
|
|
}
|
|
|
|
func TestNative_Vunsigned(t *testing.T) {
|
|
var v types.JsonState
|
|
i := 0
|
|
s := "1234"
|
|
vunsigned(&s, &i, &v)
|
|
assert.Equal(t, 4, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, int64(1234), v.Iv)
|
|
assert.Equal(t, types.V_INTEGER, v.Vt)
|
|
i = 0
|
|
s = "18446744073709551615"
|
|
vunsigned(&s, &i, &v)
|
|
assert.Equal(t, 20, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, ^int64(0), v.Iv)
|
|
assert.Equal(t, types.V_INTEGER, v.Vt)
|
|
i = 0
|
|
s = "18446744073709551616"
|
|
vunsigned(&s, &i, &v)
|
|
assert.Equal(t, 19, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt)
|
|
i = 0
|
|
s = "-1234"
|
|
vunsigned(&s, &i, &v)
|
|
assert.Equal(t, 0, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
|
|
i = 0
|
|
s = "1.234"
|
|
vunsigned(&s, &i, &v)
|
|
assert.Equal(t, 1, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
|
|
i = 0
|
|
s = "0.0125"
|
|
vunsigned(&s, &i, &v)
|
|
assert.Equal(t, 1, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
|
|
i = 0
|
|
s = "1234e5"
|
|
vunsigned(&s, &i, &v)
|
|
assert.Equal(t, 4, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
|
|
i = 0
|
|
s = "-1234e5"
|
|
vunsigned(&s, &i, &v)
|
|
assert.Equal(t, 0, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
|
|
i = 0
|
|
s = "-1.234e5"
|
|
vunsigned(&s, &i, &v)
|
|
assert.Equal(t, 0, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
|
|
i = 0
|
|
s = "-1.234e-5"
|
|
vunsigned(&s, &i, &v)
|
|
assert.Equal(t, 0, i)
|
|
assert.Equal(t, 0, v.Ep)
|
|
assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
|
|
}
|
|
|
|
func TestNative_SkipOne(t *testing.T) {
|
|
p := 0
|
|
s := ` {"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
|
|
q := skip_one(&s, &p, &types.StateMachine{}, uint64(0))
|
|
assert.Equal(t, 42, p)
|
|
assert.Equal(t, 1, q)
|
|
p = 0
|
|
s = `1 2.5 -3 "asdf\nqwer" true false null {} []`
|
|
q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
|
|
assert.Equal(t, 1, p)
|
|
assert.Equal(t, 0, q)
|
|
q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
|
|
assert.Equal(t, 5, p)
|
|
assert.Equal(t, 2, q)
|
|
q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
|
|
assert.Equal(t, 8, p)
|
|
assert.Equal(t, 6, q)
|
|
q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
|
|
assert.Equal(t, 21, p)
|
|
assert.Equal(t, 9, q)
|
|
q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
|
|
assert.Equal(t, 26, p)
|
|
assert.Equal(t, 22, q)
|
|
q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
|
|
assert.Equal(t, 32, p)
|
|
assert.Equal(t, 27, q)
|
|
q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
|
|
assert.Equal(t, 37, p)
|
|
assert.Equal(t, 33, q)
|
|
q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
|
|
assert.Equal(t, 40, p)
|
|
assert.Equal(t, 38, q)
|
|
q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
|
|
assert.Equal(t, 43, p)
|
|
assert.Equal(t, 41, q)
|
|
}
|
|
|
|
func TestNative_SkipOne_Error(t *testing.T) {
|
|
for _, s := range([]string{
|
|
"-", "+", "0.", "0. ", "+1", "0.0e ", "9e+", "0e-",
|
|
"tru", "fals", "nul", "trux", "fals ",
|
|
`"asdf`, `"\\\"`,
|
|
}) {
|
|
p := 0
|
|
q := skip_one(&s, &p, &types.StateMachine{}, uint64(0))
|
|
assert.True(t, q < 0)
|
|
}
|
|
}
|
|
|
|
func TestNative_SkipArray(t *testing.T) {
|
|
p := 0
|
|
s := `null, true, false, 1, 2.0, -3, {"asdf": "wqer"}],`
|
|
skip_array(&s, &p, &types.StateMachine{}, uint64(0))
|
|
assert.Equal(t, p, 48)
|
|
}
|
|
|
|
func TestNative_SkipObject(t *testing.T) {
|
|
p := 0
|
|
s := `"asdf": "wqer"},`
|
|
skip_object(&s, &p, &types.StateMachine{}, uint64(0))
|
|
assert.Equal(t, p, 15)
|
|
}
|
|
|
|
func TestNative_SkipNumber(t *testing.T) {
|
|
p := 0
|
|
s := `-1.23e+12`
|
|
q := skip_number(&s, &p)
|
|
assert.Equal(t, 9, p)
|
|
assert.Equal(t, 0, q)
|
|
}
|
|
|
|
func TestNative_SkipNumberInJson(t *testing.T) {
|
|
p := 0x13
|
|
s := "{\"h\":\"1.00000\",\"i\":true,\"pass3\":1}"
|
|
q := skip_number(&s, &p)
|
|
assert.Equal(t, 0x13, p)
|
|
assert.Equal(t, -2, q)
|
|
}
|
|
|
|
func TestNative_SkipOneFast(t *testing.T) {
|
|
p := 0
|
|
s := ` {"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
|
|
q := skip_one_fast(&s, &p)
|
|
assert.Equal(t, 42, p)
|
|
assert.Equal(t, 1, q)
|
|
p = 0
|
|
s = `1, 2.5, -3, "asdf\nqwer", true, false, null, {}, [],`
|
|
q = skip_one_fast(&s, &p)
|
|
assert.Equal(t, 1, p)
|
|
assert.Equal(t, 0, q)
|
|
p += 1
|
|
q = skip_one_fast(&s, &p)
|
|
assert.Equal(t, 6, p)
|
|
assert.Equal(t, 3, q)
|
|
p += 1
|
|
q = skip_one_fast(&s, &p)
|
|
assert.Equal(t, 10, p)
|
|
assert.Equal(t, 8, q)
|
|
p += 1
|
|
q = skip_one_fast(&s, &p)
|
|
assert.Equal(t, 24, p)
|
|
assert.Equal(t, 12, q)
|
|
p += 1
|
|
q = skip_one_fast(&s, &p)
|
|
assert.Equal(t, 30, p)
|
|
assert.Equal(t, 26, q)
|
|
p += 1
|
|
q = skip_one_fast(&s, &p)
|
|
assert.Equal(t, 37, p)
|
|
assert.Equal(t, 32, q)
|
|
p += 1
|
|
q = skip_one_fast(&s, &p)
|
|
assert.Equal(t, 43, p)
|
|
assert.Equal(t, 39, q)
|
|
p += 1
|
|
q = skip_one_fast(&s, &p)
|
|
assert.Equal(t, 47, p)
|
|
assert.Equal(t, 45, q)
|
|
p += 1
|
|
q = skip_one_fast(&s, &p)
|
|
assert.Equal(t, 51, p)
|
|
assert.Equal(t, 49, q)
|
|
}
|
|
|
|
func TestNative_SkipOneFast_Error(t *testing.T) {
|
|
for _, s := range([]string{
|
|
"{{", "[{", "{{}",
|
|
`"asdf`, `"\\\"`,
|
|
}) {
|
|
p := 0
|
|
q := skip_one_fast(&s, &p)
|
|
assert.True(t, q < 0)
|
|
}
|
|
}
|
|
|
|
func TestNative_GetByPath(t *testing.T) {
|
|
s := `{"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
|
|
p := 0
|
|
path := []interface{}{"asdf", 4}
|
|
ret := get_by_path(&s, &p, &path, types.NewStateMachine())
|
|
assert.Equal(t, strings.Index(s, "2.0"), ret)
|
|
}
|
|
|
|
func BenchmarkNative_SkipOneFast(b *testing.B) {
|
|
b.ResetTimer()
|
|
for i:=0; i<b.N; i++ {
|
|
s := `{"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
|
|
p := 0
|
|
_ = skip_one_fast(&s, &p)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNative_GetByPath(b *testing.B) {
|
|
b.ResetTimer()
|
|
for i:=0; i<b.N; i++ {
|
|
s := `{"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
|
|
p := 0
|
|
path := []interface{}{"asdf", 3}
|
|
sm := types.NewStateMachine()
|
|
_ = get_by_path(&s, &p, &path, sm)
|
|
types.FreeStateMachine(sm)
|
|
}
|
|
} |