mirror of
https://github.com/json-iterator/go.git
synced 2024-11-30 08:36:43 +02:00
11a37a0774
I believe that WriteMore should not call Flush for these reasons:
1. This is surprising for users because of inconsistency. Why call Flush in
WriteMore and not in WriteObjectEnd?
2. It is not necessary; callers are free to call Flush if their use case demands
it.
3. It harms performance in the common case by flushing the buffer much more
frequently than it needs to be flushed.
The stream benchmark shows a 7% benefit to removing the Flush call, and I
observed a similar speedup in my real-world use case.
benchmark old ns/op new ns/op delta
Benchmark_encode_string_with_SetEscapeHTML-8 442 437 -1.13%
Benchmark_jsoniter_large_file-8 21222 21062 -0.75%
Benchmark_json_large_file-8 40187 40266 +0.20%
Benchmark_stream_encode_big_object-8 8611 7956 -7.61%
benchmark old allocs new allocs delta
Benchmark_encode_string_with_SetEscapeHTML-8 6 6 +0.00%
Benchmark_jsoniter_large_file-8 78 78 +0.00%
Benchmark_json_large_file-8 13 13 +0.00%
Benchmark_stream_encode_big_object-8 0 0 +0.00%
benchmark old bytes new bytes delta
Benchmark_encode_string_with_SetEscapeHTML-8 760 760 +0.00%
Benchmark_jsoniter_large_file-8 4920 4920 +0.00%
Benchmark_json_large_file-8 6640 6640 +0.00%
Benchmark_stream_encode_big_object-8 0 0 +0.00%
Backwards compatibility - I believe there is little to no risk that this breaks
callers. WriteMore does not leave the JSON in a valid state, so it must be
followed by other Write* methods. To get the finished JSON out, the caller must
already be calling Flush.
87 lines
2.3 KiB
Go
87 lines
2.3 KiB
Go
package jsoniter
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func Test_writeByte_should_grow_buffer(t *testing.T) {
|
|
should := require.New(t)
|
|
stream := NewStream(ConfigDefault, nil, 1)
|
|
stream.writeByte('1')
|
|
should.Equal("1", string(stream.Buffer()))
|
|
should.Equal(1, len(stream.buf))
|
|
stream.writeByte('2')
|
|
should.Equal("12", string(stream.Buffer()))
|
|
should.Equal(2, len(stream.buf))
|
|
stream.writeThreeBytes('3', '4', '5')
|
|
should.Equal("12345", string(stream.Buffer()))
|
|
}
|
|
|
|
func Test_writeBytes_should_grow_buffer(t *testing.T) {
|
|
should := require.New(t)
|
|
stream := NewStream(ConfigDefault, nil, 1)
|
|
stream.Write([]byte{'1', '2'})
|
|
should.Equal("12", string(stream.Buffer()))
|
|
should.Equal(2, len(stream.buf))
|
|
stream.Write([]byte{'3', '4', '5', '6', '7'})
|
|
should.Equal("1234567", string(stream.Buffer()))
|
|
should.Equal(7, len(stream.buf))
|
|
}
|
|
|
|
func Test_writeIndention_should_grow_buffer(t *testing.T) {
|
|
should := require.New(t)
|
|
stream := NewStream(Config{IndentionStep: 2}.Froze(), nil, 1)
|
|
stream.WriteVal([]int{1, 2, 3})
|
|
should.Equal("[\n 1,\n 2,\n 3\n]", string(stream.Buffer()))
|
|
}
|
|
|
|
func Test_writeRaw_should_grow_buffer(t *testing.T) {
|
|
should := require.New(t)
|
|
stream := NewStream(ConfigDefault, nil, 1)
|
|
stream.WriteRaw("123")
|
|
should.Nil(stream.Error)
|
|
should.Equal("123", string(stream.Buffer()))
|
|
}
|
|
|
|
func Test_writeString_should_grow_buffer(t *testing.T) {
|
|
should := require.New(t)
|
|
stream := NewStream(ConfigDefault, nil, 0)
|
|
stream.WriteString("123")
|
|
should.Nil(stream.Error)
|
|
should.Equal(`"123"`, string(stream.Buffer()))
|
|
}
|
|
|
|
type NopWriter struct {
|
|
bufferSize int
|
|
}
|
|
|
|
func (w *NopWriter) Write(p []byte) (n int, err error) {
|
|
w.bufferSize = cap(p)
|
|
return len(p), nil
|
|
}
|
|
|
|
func Test_flush_buffer_should_stop_grow_buffer(t *testing.T) {
|
|
// Stream an array of a zillion zeros.
|
|
writer := new(NopWriter)
|
|
stream := NewStream(ConfigDefault, writer, 512)
|
|
stream.WriteArrayStart()
|
|
for i := 0; i < 10000000; i++ {
|
|
stream.WriteInt(0)
|
|
stream.WriteMore()
|
|
stream.Flush()
|
|
}
|
|
stream.WriteInt(0)
|
|
stream.WriteArrayEnd()
|
|
|
|
// Confirm that the buffer didn't have to grow.
|
|
should := require.New(t)
|
|
|
|
// 512 is the internal buffer size set in NewEncoder
|
|
//
|
|
// Flush is called after each array element, so only the first 8 bytes of it
|
|
// is ever used, and it is never extended. Capacity remains 512.
|
|
should.Equal(512, writer.bufferSize)
|
|
}
|