mirror of
https://github.com/json-iterator/go.git
synced 2025-04-20 11:28:49 +02:00
101 lines
2.6 KiB
Go
101 lines
2.6 KiB
Go
package test
|
|
|
|
import (
|
|
"testing"
|
|
"unsafe"
|
|
"time"
|
|
"github.com/json-iterator/go"
|
|
"github.com/stretchr/testify/require"
|
|
"strconv"
|
|
)
|
|
|
|
func Test_customize_type_decoder(t *testing.T) {
|
|
t.Skip()
|
|
jsoniter.RegisterTypeDecoderFunc("time.Time", func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
|
|
t, err := time.ParseInLocation("2006-01-02 15:04:05", iter.ReadString(), time.UTC)
|
|
if err != nil {
|
|
iter.Error = err
|
|
return
|
|
}
|
|
*((*time.Time)(ptr)) = t
|
|
})
|
|
//defer jsoniter.ConfigDefault.(*frozenConfig).cleanDecoders()
|
|
val := time.Time{}
|
|
err := jsoniter.Unmarshal([]byte(`"2016-12-05 08:43:28"`), &val)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
year, month, day := val.Date()
|
|
if year != 2016 || month != 12 || day != 5 {
|
|
t.Fatal(val)
|
|
}
|
|
}
|
|
|
|
func Test_customize_byte_array_encoder(t *testing.T) {
|
|
t.Skip()
|
|
//jsoniter.ConfigDefault.(*frozenConfig).cleanEncoders()
|
|
should := require.New(t)
|
|
jsoniter.RegisterTypeEncoderFunc("[]uint8", func(ptr unsafe.Pointer, stream *jsoniter.Stream) {
|
|
t := *((*[]byte)(ptr))
|
|
stream.WriteString(string(t))
|
|
}, nil)
|
|
//defer jsoniter.ConfigDefault.(*frozenConfig).cleanEncoders()
|
|
val := []byte("abc")
|
|
str, err := jsoniter.MarshalToString(val)
|
|
should.Nil(err)
|
|
should.Equal(`"abc"`, str)
|
|
}
|
|
|
|
func Test_customize_field_decoder(t *testing.T) {
|
|
type Tom struct {
|
|
field1 string
|
|
}
|
|
jsoniter.RegisterFieldDecoderFunc("jsoniter.Tom", "field1", func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
|
|
*((*string)(ptr)) = strconv.Itoa(iter.ReadInt())
|
|
})
|
|
//defer jsoniter.ConfigDefault.(*frozenConfig).cleanDecoders()
|
|
tom := Tom{}
|
|
err := jsoniter.Unmarshal([]byte(`{"field1": 100}`), &tom)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
|
|
func Test_recursive_empty_interface_customization(t *testing.T) {
|
|
t.Skip()
|
|
var obj interface{}
|
|
jsoniter.RegisterTypeDecoderFunc("interface {}", func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
|
|
switch iter.WhatIsNext() {
|
|
case jsoniter.NumberValue:
|
|
*(*interface{})(ptr) = iter.ReadInt64()
|
|
default:
|
|
*(*interface{})(ptr) = iter.Read()
|
|
}
|
|
})
|
|
should := require.New(t)
|
|
jsoniter.Unmarshal([]byte("[100]"), &obj)
|
|
should.Equal([]interface{}{int64(100)}, obj)
|
|
}
|
|
|
|
type MyInterface interface {
|
|
Hello() string
|
|
}
|
|
|
|
type MyString string
|
|
|
|
func (ms MyString) Hello() string {
|
|
return string(ms)
|
|
}
|
|
|
|
func Test_read_custom_interface(t *testing.T) {
|
|
t.Skip()
|
|
should := require.New(t)
|
|
var val MyInterface
|
|
jsoniter.RegisterTypeDecoderFunc("jsoniter.MyInterface", func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
|
|
*((*MyInterface)(ptr)) = MyString(iter.ReadString())
|
|
})
|
|
err := jsoniter.UnmarshalFromString(`"hello"`, &val)
|
|
should.Nil(err)
|
|
should.Equal("hello", val.Hello())
|
|
} |