fix build; add document for exported symbols

feature_config.go

@@ -134,7 +134,7 @@ type htmlEscapedStringEncoder struct {
 
 func (encoder *htmlEscapedStringEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
 	str := *((*string)(ptr))
-	stream.WriteStringWithHtmlEscaped(str)
+	stream.WriteStringWithHTMLEscaped(str)
 }
 
 func (encoder *htmlEscapedStringEncoder) EncodeInterface(val interface{}, stream *Stream) {

feature_iter_float.go

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

feature_stream.go

@@ -24,177 +24,177 @@ func NewStream(cfg *frozenConfig, out io.Writer, bufSize int) *Stream {
 	}
 }
 
-func (b *Stream) Reset(out io.Writer) {
-	b.out = out
-	b.n = 0
+func (stream *Stream) Reset(out io.Writer) {
+	stream.out = out
+	stream.n = 0
 }
 
 // Available returns how many bytes are unused in the buffer.
-func (b *Stream) Available() int {
-	return len(b.buf) - b.n
+func (stream *Stream) Available() int {
+	return len(stream.buf) - stream.n
 }
 
 // Buffered returns the number of bytes that have been written into the current buffer.
-func (b *Stream) Buffered() int {
-	return b.n
+func (stream *Stream) Buffered() int {
+	return stream.n
 }
 
-func (b *Stream) Buffer() []byte {
-	return b.buf[:b.n]
+func (stream *Stream) Buffer() []byte {
+	return stream.buf[:stream.n]
 }
 
 // Write writes the contents of p into the buffer.
 // It returns the number of bytes written.
 // If nn < len(p), it also returns an error explaining
 // why the write is short.
-func (b *Stream) Write(p []byte) (nn int, err error) {
-	for len(p) > b.Available() && b.Error == nil {
-		if b.out == nil {
-			b.growAtLeast(len(p))
+func (stream *Stream) Write(p []byte) (nn int, err error) {
+	for len(p) > stream.Available() && stream.Error == nil {
+		if stream.out == nil {
+			stream.growAtLeast(len(p))
 		} else {
 			var n int
-			if b.Buffered() == 0 {
+			if stream.Buffered() == 0 {
 				// Large write, empty buffer.
 				// Write directly from p to avoid copy.
-				n, b.Error = b.out.Write(p)
+				n, stream.Error = stream.out.Write(p)
 			} else {
-				n = copy(b.buf[b.n:], p)
-				b.n += n
-				b.Flush()
+				n = copy(stream.buf[stream.n:], p)
+				stream.n += n
+				stream.Flush()
 			}
 			nn += n
 			p = p[n:]
 		}
 	}
-	if b.Error != nil {
-		return nn, b.Error
+	if stream.Error != nil {
+		return nn, stream.Error
 	}
-	n := copy(b.buf[b.n:], p)
-	b.n += n
+	n := copy(stream.buf[stream.n:], p)
+	stream.n += n
 	nn += n
 	return nn, nil
 }
 
 // WriteByte writes a single byte.
-func (b *Stream) writeByte(c byte) {
-	if b.Error != nil {
+func (stream *Stream) writeByte(c byte) {
+	if stream.Error != nil {
 		return
 	}
-	if b.Available() < 1 {
-		b.growAtLeast(1)
+	if stream.Available() < 1 {
+		stream.growAtLeast(1)
 	}
-	b.buf[b.n] = c
-	b.n++
+	stream.buf[stream.n] = c
+	stream.n++
 }
 
-func (b *Stream) writeTwoBytes(c1 byte, c2 byte) {
-	if b.Error != nil {
+func (stream *Stream) writeTwoBytes(c1 byte, c2 byte) {
+	if stream.Error != nil {
 		return
 	}
-	if b.Available() < 2 {
-		b.growAtLeast(2)
+	if stream.Available() < 2 {
+		stream.growAtLeast(2)
 	}
-	b.buf[b.n] = c1
-	b.buf[b.n+1] = c2
-	b.n += 2
+	stream.buf[stream.n] = c1
+	stream.buf[stream.n+1] = c2
+	stream.n += 2
 }
 
-func (b *Stream) writeThreeBytes(c1 byte, c2 byte, c3 byte) {
-	if b.Error != nil {
+func (stream *Stream) writeThreeBytes(c1 byte, c2 byte, c3 byte) {
+	if stream.Error != nil {
 		return
 	}
-	if b.Available() < 3 {
-		b.growAtLeast(3)
+	if stream.Available() < 3 {
+		stream.growAtLeast(3)
 	}
-	b.buf[b.n] = c1
-	b.buf[b.n+1] = c2
-	b.buf[b.n+2] = c3
-	b.n += 3
+	stream.buf[stream.n] = c1
+	stream.buf[stream.n+1] = c2
+	stream.buf[stream.n+2] = c3
+	stream.n += 3
 }
 
-func (b *Stream) writeFourBytes(c1 byte, c2 byte, c3 byte, c4 byte) {
-	if b.Error != nil {
+func (stream *Stream) writeFourBytes(c1 byte, c2 byte, c3 byte, c4 byte) {
+	if stream.Error != nil {
 		return
 	}
-	if b.Available() < 4 {
-		b.growAtLeast(4)
+	if stream.Available() < 4 {
+		stream.growAtLeast(4)
 	}
-	b.buf[b.n] = c1
-	b.buf[b.n+1] = c2
-	b.buf[b.n+2] = c3
-	b.buf[b.n+3] = c4
-	b.n += 4
+	stream.buf[stream.n] = c1
+	stream.buf[stream.n+1] = c2
+	stream.buf[stream.n+2] = c3
+	stream.buf[stream.n+3] = c4
+	stream.n += 4
 }
 
-func (b *Stream) writeFiveBytes(c1 byte, c2 byte, c3 byte, c4 byte, c5 byte) {
-	if b.Error != nil {
+func (stream *Stream) writeFiveBytes(c1 byte, c2 byte, c3 byte, c4 byte, c5 byte) {
+	if stream.Error != nil {
 		return
 	}
-	if b.Available() < 5 {
-		b.growAtLeast(5)
+	if stream.Available() < 5 {
+		stream.growAtLeast(5)
 	}
-	b.buf[b.n] = c1
-	b.buf[b.n+1] = c2
-	b.buf[b.n+2] = c3
-	b.buf[b.n+3] = c4
-	b.buf[b.n+4] = c5
-	b.n += 5
+	stream.buf[stream.n] = c1
+	stream.buf[stream.n+1] = c2
+	stream.buf[stream.n+2] = c3
+	stream.buf[stream.n+3] = c4
+	stream.buf[stream.n+4] = c5
+	stream.n += 5
 }
 
 // Flush writes any buffered data to the underlying io.Writer.
-func (b *Stream) Flush() error {
-	if b.out == nil {
+func (stream *Stream) Flush() error {
+	if stream.out == nil {
 		return nil
 	}
-	if b.Error != nil {
-		return b.Error
+	if stream.Error != nil {
+		return stream.Error
 	}
-	if b.n == 0 {
+	if stream.n == 0 {
 		return nil
 	}
-	n, err := b.out.Write(b.buf[0:b.n])
-	if n < b.n && err == nil {
+	n, err := stream.out.Write(stream.buf[0:stream.n])
+	if n < stream.n && err == nil {
 		err = io.ErrShortWrite
 	}
 	if err != nil {
-		if n > 0 && n < b.n {
-			copy(b.buf[0:b.n-n], b.buf[n:b.n])
+		if n > 0 && n < stream.n {
+			copy(stream.buf[0:stream.n-n], stream.buf[n:stream.n])
 		}
-		b.n -= n
-		b.Error = err
+		stream.n -= n
+		stream.Error = err
 		return err
 	}
-	b.n = 0
+	stream.n = 0
 	return nil
 }
 
-func (b *Stream) ensure(minimal int) {
-	available := b.Available()
+func (stream *Stream) ensure(minimal int) {
+	available := stream.Available()
 	if available < minimal {
-		if b.n > 1024 {
-			b.Flush()
+		if stream.n > 1024 {
+			stream.Flush()
 		}
-		b.growAtLeast(minimal)
+		stream.growAtLeast(minimal)
 	}
 }
 
-func (b *Stream) growAtLeast(minimal int) {
-	toGrow := len(b.buf)
+func (stream *Stream) growAtLeast(minimal int) {
+	toGrow := len(stream.buf)
 	if toGrow < minimal {
 		toGrow = minimal
 	}
-	newBuf := make([]byte, len(b.buf)+toGrow)
-	copy(newBuf, b.Buffer())
-	b.buf = newBuf
+	newBuf := make([]byte, len(stream.buf)+toGrow)
+	copy(newBuf, stream.Buffer())
+	stream.buf = newBuf
 }
 
-func (b *Stream) WriteRaw(s string) {
-	b.ensure(len(s))
-	if b.Error != nil {
+func (stream *Stream) WriteRaw(s string) {
+	stream.ensure(len(s))
+	if stream.Error != nil {
 		return
 	}
-	n := copy(b.buf[b.n:], s)
-	b.n += n
+	n := copy(stream.buf[stream.n:], s)
+	stream.n += n
 }
 
 func (stream *Stream) WriteNil() {

feature_stream_float.go

@@ -5,12 +5,13 @@ import (
 	"strconv"
 )
 
-var _POW10 []uint64
+var pow10 []uint64
 
 func init() {
-	_POW10 = []uint64{1, 10, 100, 1000, 10000, 100000, 1000000}
+	pow10 = []uint64{1, 10, 100, 1000, 10000, 100000, 1000000}
 }
 
+// WriteFloat32 write float32 to stream
 func (stream *Stream) WriteFloat32(val float32) {
 	abs := math.Abs(float64(val))
 	fmt := byte('f')
@@ -23,6 +24,7 @@ func (stream *Stream) WriteFloat32(val float32) {
 	stream.WriteRaw(strconv.FormatFloat(float64(val), fmt, -1, 32))
 }
 
+// WriteFloat32Lossy write float32 to stream with ONLY 6 digits precision although much much faster
 func (stream *Stream) WriteFloat32Lossy(val float32) {
 	if val < 0 {
 		stream.writeByte('-')
@@ -42,7 +44,7 @@ func (stream *Stream) WriteFloat32Lossy(val float32) {
 	}
 	stream.writeByte('.')
 	stream.ensure(10)
-	for p := precision - 1; p > 0 && fval < _POW10[p]; p-- {
+	for p := precision - 1; p > 0 && fval < pow10[p]; p-- {
 		stream.writeByte('0')
 	}
 	stream.WriteUint64(fval)
@@ -51,6 +53,7 @@ func (stream *Stream) WriteFloat32Lossy(val float32) {
 	}
 }
 
+// WriteFloat64 write float64 to stream
 func (stream *Stream) WriteFloat64(val float64) {
 	abs := math.Abs(val)
 	fmt := byte('f')
@@ -63,6 +66,7 @@ func (stream *Stream) WriteFloat64(val float64) {
 	stream.WriteRaw(strconv.FormatFloat(float64(val), fmt, -1, 64))
 }
 
+// WriteFloat64Lossy write float64 to stream with ONLY 6 digits precision although much much faster
 func (stream *Stream) WriteFloat64Lossy(val float64) {
 	if val < 0 {
 		stream.writeByte('-')
@@ -82,7 +86,7 @@ func (stream *Stream) WriteFloat64Lossy(val float64) {
 	}
 	stream.writeByte('.')
 	stream.ensure(10)
-	for p := precision - 1; p > 0 && fval < _POW10[p]; p-- {
+	for p := precision - 1; p > 0 && fval < pow10[p]; p-- {
 		stream.writeByte('0')
 	}
 	stream.WriteUint64(fval)

feature_stream_int.go

@@ -1,15 +1,15 @@
 package jsoniter
 
-var _DIGITS []uint32
+var digits []uint32
 
 func init() {
-	_DIGITS = make([]uint32, 1000)
+	digits = make([]uint32, 1000)
 	for i := uint32(0); i < 1000; i++ {
-		_DIGITS[i] = (((i / 100) + '0') << 16) + ((((i / 10) % 10) + '0') << 8) + i%10 + '0'
+		digits[i] = (((i / 100) + '0') << 16) + ((((i / 10) % 10) + '0') << 8) + i%10 + '0'
 		if i < 10 {
-			_DIGITS[i] += 2 << 24
+			digits[i] += 2 << 24
 		} else if i < 100 {
-			_DIGITS[i] += 1 << 24
+			digits[i] += 1 << 24
 		}
 	}
 }
@@ -36,11 +36,13 @@ func writeBuf(buf []byte, v uint32, n int) {
 	buf[n+2] = byte(v)
 }
 
+// WriteUint8 write uint8 to stream
 func (stream *Stream) WriteUint8(val uint8) {
 	stream.ensure(3)
-	stream.n = writeFirstBuf(stream.buf, _DIGITS[val], stream.n)
+	stream.n = writeFirstBuf(stream.buf, digits[val], stream.n)
 }
 
+// WriteInt8 write int8 to stream
 func (stream *Stream) WriteInt8(nval int8) {
 	stream.ensure(4)
 	n := stream.n
@@ -52,23 +54,25 @@ func (stream *Stream) WriteInt8(nval int8) {
 	} else {
 		val = uint8(nval)
 	}
-	stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
+	stream.n = writeFirstBuf(stream.buf, digits[val], n)
 }
 
+// WriteUint16 write uint16 to stream
 func (stream *Stream) WriteUint16(val uint16) {
 	stream.ensure(5)
 	q1 := val / 1000
 	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, _DIGITS[val], stream.n)
+		stream.n = writeFirstBuf(stream.buf, digits[val], stream.n)
 		return
 	}
 	r1 := val - q1*1000
-	n := writeFirstBuf(stream.buf, _DIGITS[q1], stream.n)
-	writeBuf(stream.buf, _DIGITS[r1], n)
+	n := writeFirstBuf(stream.buf, digits[q1], stream.n)
+	writeBuf(stream.buf, digits[r1], n)
 	stream.n = n + 3
 	return
 }
 
+// WriteInt16 write int16 to stream
 func (stream *Stream) WriteInt16(nval int16) {
 	stream.ensure(6)
 	n := stream.n
@@ -82,48 +86,50 @@ func (stream *Stream) WriteInt16(nval int16) {
 	}
 	q1 := val / 1000
 	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
+		stream.n = writeFirstBuf(stream.buf, digits[val], n)
 		return
 	}
 	r1 := val - q1*1000
-	n = writeFirstBuf(stream.buf, _DIGITS[q1], n)
-	writeBuf(stream.buf, _DIGITS[r1], n)
+	n = writeFirstBuf(stream.buf, digits[q1], n)
+	writeBuf(stream.buf, digits[r1], n)
 	stream.n = n + 3
 	return
 }
 
+// WriteUint32 write uint32 to stream
 func (stream *Stream) WriteUint32(val uint32) {
 	stream.ensure(10)
 	n := stream.n
 	q1 := val / 1000
 	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
+		stream.n = writeFirstBuf(stream.buf, digits[val], n)
 		return
 	}
 	r1 := val - q1*1000
 	q2 := q1 / 1000
 	if q2 == 0 {
-		n := writeFirstBuf(stream.buf, _DIGITS[q1], n)
-		writeBuf(stream.buf, _DIGITS[r1], n)
+		n := writeFirstBuf(stream.buf, digits[q1], n)
+		writeBuf(stream.buf, digits[r1], n)
 		stream.n = n + 3
 		return
 	}
 	r2 := q1 - q2*1000
 	q3 := q2 / 1000
 	if q3 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q2], n)
+		n = writeFirstBuf(stream.buf, digits[q2], n)
 	} else {
 		r3 := q2 - q3*1000
 		stream.buf[n] = byte(q3 + '0')
 		n++
-		writeBuf(stream.buf, _DIGITS[r3], n)
+		writeBuf(stream.buf, digits[r3], n)
 		n += 3
 	}
-	writeBuf(stream.buf, _DIGITS[r2], n)
-	writeBuf(stream.buf, _DIGITS[r1], n+3)
+	writeBuf(stream.buf, digits[r2], n)
+	writeBuf(stream.buf, digits[r1], n+3)
 	stream.n = n + 6
 }
 
+// WriteInt32 write int32 to stream
 func (stream *Stream) WriteInt32(nval int32) {
 	stream.ensure(11)
 	n := stream.n
@@ -137,97 +143,99 @@ func (stream *Stream) WriteInt32(nval int32) {
 	}
 	q1 := val / 1000
 	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
+		stream.n = writeFirstBuf(stream.buf, digits[val], n)
 		return
 	}
 	r1 := val - q1*1000
 	q2 := q1 / 1000
 	if q2 == 0 {
-		n := writeFirstBuf(stream.buf, _DIGITS[q1], n)
-		writeBuf(stream.buf, _DIGITS[r1], n)
+		n := writeFirstBuf(stream.buf, digits[q1], n)
+		writeBuf(stream.buf, digits[r1], n)
 		stream.n = n + 3
 		return
 	}
 	r2 := q1 - q2*1000
 	q3 := q2 / 1000
 	if q3 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q2], n)
+		n = writeFirstBuf(stream.buf, digits[q2], n)
 	} else {
 		r3 := q2 - q3*1000
 		stream.buf[n] = byte(q3 + '0')
 		n++
-		writeBuf(stream.buf, _DIGITS[r3], n)
+		writeBuf(stream.buf, digits[r3], n)
 		n += 3
 	}
-	writeBuf(stream.buf, _DIGITS[r2], n)
-	writeBuf(stream.buf, _DIGITS[r1], n+3)
+	writeBuf(stream.buf, digits[r2], n)
+	writeBuf(stream.buf, digits[r1], n+3)
 	stream.n = n + 6
 }
 
+// WriteUint64 write uint64 to stream
 func (stream *Stream) WriteUint64(val uint64) {
 	stream.ensure(20)
 	n := stream.n
 	q1 := val / 1000
 	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
+		stream.n = writeFirstBuf(stream.buf, digits[val], n)
 		return
 	}
 	r1 := val - q1*1000
 	q2 := q1 / 1000
 	if q2 == 0 {
-		n := writeFirstBuf(stream.buf, _DIGITS[q1], n)
-		writeBuf(stream.buf, _DIGITS[r1], n)
+		n := writeFirstBuf(stream.buf, digits[q1], n)
+		writeBuf(stream.buf, digits[r1], n)
 		stream.n = n + 3
 		return
 	}
 	r2 := q1 - q2*1000
 	q3 := q2 / 1000
 	if q3 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q2], n)
-		writeBuf(stream.buf, _DIGITS[r2], n)
-		writeBuf(stream.buf, _DIGITS[r1], n+3)
+		n = writeFirstBuf(stream.buf, digits[q2], n)
+		writeBuf(stream.buf, digits[r2], n)
+		writeBuf(stream.buf, digits[r1], n+3)
 		stream.n = n + 6
 		return
 	}
 	r3 := q2 - q3*1000
 	q4 := q3 / 1000
 	if q4 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q3], n)
-		writeBuf(stream.buf, _DIGITS[r3], n)
-		writeBuf(stream.buf, _DIGITS[r2], n+3)
-		writeBuf(stream.buf, _DIGITS[r1], n+6)
+		n = writeFirstBuf(stream.buf, digits[q3], n)
+		writeBuf(stream.buf, digits[r3], n)
+		writeBuf(stream.buf, digits[r2], n+3)
+		writeBuf(stream.buf, digits[r1], n+6)
 		stream.n = n + 9
 		return
 	}
 	r4 := q3 - q4*1000
 	q5 := q4 / 1000
 	if q5 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q4], n)
-		writeBuf(stream.buf, _DIGITS[r4], n)
-		writeBuf(stream.buf, _DIGITS[r3], n+3)
-		writeBuf(stream.buf, _DIGITS[r2], n+6)
-		writeBuf(stream.buf, _DIGITS[r1], n+9)
+		n = writeFirstBuf(stream.buf, digits[q4], n)
+		writeBuf(stream.buf, digits[r4], n)
+		writeBuf(stream.buf, digits[r3], n+3)
+		writeBuf(stream.buf, digits[r2], n+6)
+		writeBuf(stream.buf, digits[r1], n+9)
 		stream.n = n + 12
 		return
 	}
 	r5 := q4 - q5*1000
 	q6 := q5 / 1000
 	if q6 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q5], n)
+		n = writeFirstBuf(stream.buf, digits[q5], n)
 	} else {
-		n = writeFirstBuf(stream.buf, _DIGITS[q6], n)
+		n = writeFirstBuf(stream.buf, digits[q6], n)
 		r6 := q5 - q6*1000
-		writeBuf(stream.buf, _DIGITS[r6], n)
+		writeBuf(stream.buf, digits[r6], n)
 		n += 3
 	}
-	writeBuf(stream.buf, _DIGITS[r5], n)
-	writeBuf(stream.buf, _DIGITS[r4], n+3)
-	writeBuf(stream.buf, _DIGITS[r3], n+6)
-	writeBuf(stream.buf, _DIGITS[r2], n+9)
-	writeBuf(stream.buf, _DIGITS[r1], n+12)
+	writeBuf(stream.buf, digits[r5], n)
+	writeBuf(stream.buf, digits[r4], n+3)
+	writeBuf(stream.buf, digits[r3], n+6)
+	writeBuf(stream.buf, digits[r2], n+9)
+	writeBuf(stream.buf, digits[r1], n+12)
 	stream.n = n + 15
 }
 
+// WriteInt64 write int64 to stream
 func (stream *Stream) WriteInt64(nval int64) {
 	stream.ensure(20)
 	n := stream.n
@@ -241,70 +249,72 @@ func (stream *Stream) WriteInt64(nval int64) {
 	}
 	q1 := val / 1000
 	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
+		stream.n = writeFirstBuf(stream.buf, digits[val], n)
 		return
 	}
 	r1 := val - q1*1000
 	q2 := q1 / 1000
 	if q2 == 0 {
-		n := writeFirstBuf(stream.buf, _DIGITS[q1], n)
-		writeBuf(stream.buf, _DIGITS[r1], n)
+		n := writeFirstBuf(stream.buf, digits[q1], n)
+		writeBuf(stream.buf, digits[r1], n)
 		stream.n = n + 3
 		return
 	}
 	r2 := q1 - q2*1000
 	q3 := q2 / 1000
 	if q3 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q2], n)
-		writeBuf(stream.buf, _DIGITS[r2], n)
-		writeBuf(stream.buf, _DIGITS[r1], n+3)
+		n = writeFirstBuf(stream.buf, digits[q2], n)
+		writeBuf(stream.buf, digits[r2], n)
+		writeBuf(stream.buf, digits[r1], n+3)
 		stream.n = n + 6
 		return
 	}
 	r3 := q2 - q3*1000
 	q4 := q3 / 1000
 	if q4 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q3], n)
-		writeBuf(stream.buf, _DIGITS[r3], n)
-		writeBuf(stream.buf, _DIGITS[r2], n+3)
-		writeBuf(stream.buf, _DIGITS[r1], n+6)
+		n = writeFirstBuf(stream.buf, digits[q3], n)
+		writeBuf(stream.buf, digits[r3], n)
+		writeBuf(stream.buf, digits[r2], n+3)
+		writeBuf(stream.buf, digits[r1], n+6)
 		stream.n = n + 9
 		return
 	}
 	r4 := q3 - q4*1000
 	q5 := q4 / 1000
 	if q5 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q4], n)
-		writeBuf(stream.buf, _DIGITS[r4], n)
-		writeBuf(stream.buf, _DIGITS[r3], n+3)
-		writeBuf(stream.buf, _DIGITS[r2], n+6)
-		writeBuf(stream.buf, _DIGITS[r1], n+9)
+		n = writeFirstBuf(stream.buf, digits[q4], n)
+		writeBuf(stream.buf, digits[r4], n)
+		writeBuf(stream.buf, digits[r3], n+3)
+		writeBuf(stream.buf, digits[r2], n+6)
+		writeBuf(stream.buf, digits[r1], n+9)
 		stream.n = n + 12
 		return
 	}
 	r5 := q4 - q5*1000
 	q6 := q5 / 1000
 	if q6 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q5], n)
+		n = writeFirstBuf(stream.buf, digits[q5], n)
 	} else {
 		stream.buf[n] = byte(q6 + '0')
 		n++
 		r6 := q5 - q6*1000
-		writeBuf(stream.buf, _DIGITS[r6], n)
+		writeBuf(stream.buf, digits[r6], n)
 		n += 3
 	}
-	writeBuf(stream.buf, _DIGITS[r5], n)
-	writeBuf(stream.buf, _DIGITS[r4], n+3)
-	writeBuf(stream.buf, _DIGITS[r3], n+6)
-	writeBuf(stream.buf, _DIGITS[r2], n+9)
-	writeBuf(stream.buf, _DIGITS[r1], n+12)
+	writeBuf(stream.buf, digits[r5], n)
+	writeBuf(stream.buf, digits[r4], n+3)
+	writeBuf(stream.buf, digits[r3], n+6)
+	writeBuf(stream.buf, digits[r2], n+9)
+	writeBuf(stream.buf, digits[r1], n+12)
 	stream.n = n + 15
 }
 
+// WriteInt write int to stream
 func (stream *Stream) WriteInt(val int) {
 	stream.WriteInt64(int64(val))
 }
 
+// WriteUint write uint to stream
 func (stream *Stream) WriteUint(val uint) {
 	stream.WriteUint64(uint64(val))
 }

feature_stream_string.go

@@ -217,7 +217,8 @@ var safeSet = [utf8.RuneSelf]bool{
 
 var hex = "0123456789abcdef"
 
-func (stream *Stream) WriteStringWithHtmlEscaped(s string) {
+// WriteStringWithHTMLEscaped write string to stream with html special characters escaped
+func (stream *Stream) WriteStringWithHTMLEscaped(s string) {
 	stream.ensure(32)
 	valLen := len(s)
 	toWriteLen := valLen
@@ -246,10 +247,10 @@ func (stream *Stream) WriteStringWithHtmlEscaped(s string) {
 		return
 	}
 	stream.n = n
-	writeStringSlowPathWithHtmlEscaped(stream, i, s, valLen)
+	writeStringSlowPathWithHTMLEscaped(stream, i, s, valLen)
 }
 
-func writeStringSlowPathWithHtmlEscaped(stream *Stream, i int, s string, valLen int) {
+func writeStringSlowPathWithHTMLEscaped(stream *Stream, i int, s string, valLen int) {
 	start := i
 	// for the remaining parts, we process them char by char
 	for i < valLen {
@@ -316,6 +317,7 @@ func writeStringSlowPathWithHtmlEscaped(stream *Stream, i int, s string, valLen
 	stream.writeByte('"')
 }
 
+// WriteString write string to stream without html escape
 func (stream *Stream) WriteString(s string) {
 	stream.ensure(32)
 	valLen := len(s)

jsoniter_alias_test.go

@@ -25,7 +25,7 @@ func Test_alias(t *testing.T) {
 	type myuintptr uintptr
 	var a struct {
 		A myint8    `json:"a"`
-		B myint16   `json:"b"`
+		B myint16   `json:"stream"`
 		C myint32   `json:"c"`
 		D myint64   `json:"d"`
 		E myuint8   `json:"e"`
@@ -41,7 +41,7 @@ func Test_alias(t *testing.T) {
 		O myuintptr `json:"o"`
 	}
 
-	should.Nil(UnmarshalFromString(`{"a" : 1, "b" : 1, "c": 1, "d" : 1, "e" : 1, "f" : 1, "g" : 1, "h": 1, "i" : 1, "j" : 1, "k" :"xxxx", "l" : 1, "m":1, "n": true, "o" : 1}`, &a))
+	should.Nil(UnmarshalFromString(`{"a" : 1, "stream" : 1, "c": 1, "d" : 1, "e" : 1, "f" : 1, "g" : 1, "h": 1, "i" : 1, "j" : 1, "k" :"xxxx", "l" : 1, "m":1, "n": true, "o" : 1}`, &a))
 	should.Equal(myfloat32(1), a.I)
 	should.Equal(myfloat64(1), a.J)
 	should.Equal(myint8(1), a.A)
@@ -57,6 +57,6 @@ func Test_alias(t *testing.T) {
 	should.Equal(myuintptr(1), a.O)
 	b, err := Marshal(a)
 	should.Nil(err)
-	should.Equal(`{"a":1,"b":1,"c":1,"d":1,"e":1,"f":1,"g":1,"h":1,"i":1,"j":1,"k":"xxxx","l":1,"m":1,"n":true,"o":1}`, string(b))
+	should.Equal(`{"a":1,"stream":1,"c":1,"d":1,"e":1,"f":1,"g":1,"h":1,"i":1,"j":1,"k":"xxxx","l":1,"m":1,"n":true,"o":1}`, string(b))
 
 }

jsoniter_any_object_test.go

@@ -8,13 +8,13 @@ import (
 
 func Test_read_object_as_any(t *testing.T) {
 	should := require.New(t)
-	any := Get([]byte(`{"a":"b","c":"d"}`))
-	should.Equal(`{"a":"b","c":"d"}`, any.ToString())
+	any := Get([]byte(`{"a":"stream","c":"d"}`))
+	should.Equal(`{"a":"stream","c":"d"}`, any.ToString())
 	// partial parse
-	should.Equal("b", any.Get("a").ToString())
+	should.Equal("stream", any.Get("a").ToString())
 	should.Equal("d", any.Get("c").ToString())
 	should.Equal(2, len(any.Keys()))
-	any = Get([]byte(`{"a":"b","c":"d"}`))
+	any = Get([]byte(`{"a":"stream","c":"d"}`))
 	// full parse
 	should.Equal(2, len(any.Keys()))
 	should.Equal(2, any.Size())
@@ -22,30 +22,30 @@ func Test_read_object_as_any(t *testing.T) {
 	should.Equal(0, any.ToInt())
 	should.Equal(Object, any.ValueType())
 	should.Nil(any.LastError())
-	should.Equal("b", any.GetObject()["a"].ToString())
+	should.Equal("stream", any.GetObject()["a"].ToString())
 	obj := struct {
 		A string
 	}{}
 	any.ToVal(&obj)
-	should.Equal("b", obj.A)
+	should.Equal("stream", obj.A)
 }
 
 func Test_object_lazy_any_get(t *testing.T) {
 	should := require.New(t)
-	any := Get([]byte(`{"a":{"b":{"c":"d"}}}`))
-	should.Equal("d", any.Get("a", "b", "c").ToString())
+	any := Get([]byte(`{"a":{"stream":{"c":"d"}}}`))
+	should.Equal("d", any.Get("a", "stream", "c").ToString())
 }
 
 func Test_object_lazy_any_get_all(t *testing.T) {
 	should := require.New(t)
-	any := Get([]byte(`{"a":[0],"b":[1]}`))
+	any := Get([]byte(`{"a":[0],"stream":[1]}`))
 	should.Contains(any.Get('*', 0).ToString(), `"a":0`)
 }
 
 func Test_object_lazy_any_get_invalid(t *testing.T) {
 	should := require.New(t)
 	any := Get([]byte(`{}`))
-	should.Equal(Invalid, any.Get("a", "b", "c").ValueType())
+	should.Equal(Invalid, any.Get("a", "stream", "c").ValueType())
 	should.Equal(Invalid, any.Get(1).ValueType())
 }
 

jsoniter_any_string_test.go

@@ -26,7 +26,7 @@ var stringConvertMap = map[string]string{
 	"[1,2]":             "[1,2]",
 	"{}":                "{}",
 	"{1,2}":             "{1,2}",
-	`{"a":1, "b":true}`: `{"a":1, "b":true}`,
+	`{"a":1, "stream":true}`: `{"a":1, "stream":true}`,
 }
 
 func Test_read_any_to_string(t *testing.T) {

jsoniter_io_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"io"
 	"testing"
+	"github.com/stretchr/testify/require"
 )
 
 func Test_read_by_one(t *testing.T) {
@@ -34,36 +35,21 @@ func Test_read_by_one(t *testing.T) {
 }
 
 func Test_read_by_two(t *testing.T) {
+	should := require.New(t)
 	iter := Parse(ConfigDefault, bytes.NewBufferString("abc"), 2)
 	b := iter.readByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
-	if b != 'a' {
-		t.Fatal(b)
-	}
+	should.Nil(iter.Error)
+	should.Equal(byte('a'), b)
 	b = iter.readByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
-	if b != 'b' {
-		t.Fatal(b)
-	}
+	should.Nil(iter.Error)
+	should.Equal(byte('b'), b)
 	iter.unreadByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
+	should.Nil(iter.Error)
 	iter.unreadByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
+	should.Nil(iter.Error)
 	b = iter.readByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
-	if b != 'a' {
-		t.Fatal(b)
-	}
+	should.Nil(iter.Error)
+	should.Equal(byte('a'), b)
 }
 
 func Test_read_until_eof(t *testing.T) {

jsoniter_object_test.go

@@ -22,14 +22,14 @@ func Test_empty_object(t *testing.T) {
 
 func Test_one_field(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigDefault, `{"a": "b"}`)
+	iter := ParseString(ConfigDefault, `{"a": "stream"}`)
 	field := iter.ReadObject()
 	should.Equal("a", field)
 	value := iter.ReadString()
-	should.Equal("b", value)
+	should.Equal("stream", value)
 	field = iter.ReadObject()
 	should.Equal("", field)
-	iter = ParseString(ConfigDefault, `{"a": "b"}`)
+	iter = ParseString(ConfigDefault, `{"a": "stream"}`)
 	should.True(iter.ReadObjectCB(func(iter *Iterator, field string) bool {
 		should.Equal("a", field)
 		return true
@@ -39,11 +39,11 @@ func Test_one_field(t *testing.T) {
 
 func Test_two_field(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigDefault, `{ "a": "b" , "c": "d" }`)
+	iter := ParseString(ConfigDefault, `{ "a": "stream" , "c": "d" }`)
 	field := iter.ReadObject()
 	should.Equal("a", field)
 	value := iter.ReadString()
-	should.Equal("b", value)
+	should.Equal("stream", value)
 	field = iter.ReadObject()
 	should.Equal("c", field)
 	value = iter.ReadString()
@@ -115,9 +115,9 @@ func Test_decode_two_fields_struct(t *testing.T) {
 	obj := TestObject{}
 	should.Nil(UnmarshalFromString(`{}`, &obj))
 	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b"}`, &obj))
+	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream"}`, &obj))
 	should.Equal("a", obj.Field1)
-	should.Equal("b", obj.Field2)
+	should.Equal("stream", obj.Field2)
 }
 
 func Test_decode_three_fields_struct(t *testing.T) {
@@ -130,9 +130,9 @@ func Test_decode_three_fields_struct(t *testing.T) {
 	obj := TestObject{}
 	should.Nil(UnmarshalFromString(`{}`, &obj))
 	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b", "Field3": "c"}`, &obj))
+	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream", "Field3": "c"}`, &obj))
 	should.Equal("a", obj.Field1)
-	should.Equal("b", obj.Field2)
+	should.Equal("stream", obj.Field2)
 	should.Equal("c", obj.Field3)
 }
 
@@ -147,9 +147,9 @@ func Test_decode_four_fields_struct(t *testing.T) {
 	obj := TestObject{}
 	should.Nil(UnmarshalFromString(`{}`, &obj))
 	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d"}`, &obj))
+	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d"}`, &obj))
 	should.Equal("a", obj.Field1)
-	should.Equal("b", obj.Field2)
+	should.Equal("stream", obj.Field2)
 	should.Equal("c", obj.Field3)
 	should.Equal("d", obj.Field4)
 }
@@ -166,9 +166,9 @@ func Test_decode_five_fields_struct(t *testing.T) {
 	obj := TestObject{}
 	should.Nil(UnmarshalFromString(`{}`, &obj))
 	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
+	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
 	should.Equal("a", obj.Field1)
-	should.Equal("b", obj.Field2)
+	should.Equal("stream", obj.Field2)
 	should.Equal("c", obj.Field3)
 	should.Equal("d", obj.Field4)
 	should.Equal("e", obj.Field5)
@@ -187,9 +187,9 @@ func Test_decode_six_fields_struct(t *testing.T) {
 	obj := TestObject{}
 	should.Nil(UnmarshalFromString(`{}`, &obj))
 	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d", "Field5": "e", "Field6": "x"}`, &obj))
+	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e", "Field6": "x"}`, &obj))
 	should.Equal("a", obj.Field1)
-	should.Equal("b", obj.Field2)
+	should.Equal("stream", obj.Field2)
 	should.Equal("c", obj.Field3)
 	should.Equal("d", obj.Field4)
 	should.Equal("e", obj.Field5)
@@ -210,9 +210,9 @@ func Test_decode_seven_fields_struct(t *testing.T) {
 	obj := TestObject{}
 	should.Nil(UnmarshalFromString(`{}`, &obj))
 	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d", "Field5": "e", "Field6": "x", "Field7":"y"}`, &obj))
+	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e", "Field6": "x", "Field7":"y"}`, &obj))
 	should.Equal("a", obj.Field1)
-	should.Equal("b", obj.Field2)
+	should.Equal("stream", obj.Field2)
 	should.Equal("c", obj.Field3)
 	should.Equal("d", obj.Field4)
 	should.Equal("e", obj.Field5)
@@ -235,9 +235,9 @@ func Test_decode_eight_fields_struct(t *testing.T) {
 	obj := TestObject{}
 	should.Nil(UnmarshalFromString(`{}`, &obj))
 	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field8":"1", "Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d", "Field5": "e", "Field6": "x", "Field7":"y"}`, &obj))
+	should.Nil(UnmarshalFromString(`{"Field8":"1", "Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e", "Field6": "x", "Field7":"y"}`, &obj))
 	should.Equal("a", obj.Field1)
-	should.Equal("b", obj.Field2)
+	should.Equal("stream", obj.Field2)
 	should.Equal("c", obj.Field3)
 	should.Equal("d", obj.Field4)
 	should.Equal("e", obj.Field5)
@@ -262,9 +262,9 @@ func Test_decode_nine_fields_struct(t *testing.T) {
 	obj := TestObject{}
 	should.Nil(UnmarshalFromString(`{}`, &obj))
 	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field8" : "zzzzzzzzzzz", "Field7": "zz", "Field6" : "xx", "Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d", "Field5": "e", "Field9":"f"}`, &obj))
+	should.Nil(UnmarshalFromString(`{"Field8" : "zzzzzzzzzzz", "Field7": "zz", "Field6" : "xx", "Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e", "Field9":"f"}`, &obj))
 	should.Equal("a", obj.Field1)
-	should.Equal("b", obj.Field2)
+	should.Equal("stream", obj.Field2)
 	should.Equal("c", obj.Field3)
 	should.Equal("d", obj.Field4)
 	should.Equal("e", obj.Field5)
@@ -291,9 +291,9 @@ func Test_decode_ten_fields_struct(t *testing.T) {
 	obj := TestObject{}
 	should.Nil(UnmarshalFromString(`{}`, &obj))
 	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field10":"x", "Field9": "x", "Field8":"x", "Field7":"x", "Field6":"x", "Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
+	should.Nil(UnmarshalFromString(`{"Field10":"x", "Field9": "x", "Field8":"x", "Field7":"x", "Field6":"x", "Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
 	should.Equal("a", obj.Field1)
-	should.Equal("b", obj.Field2)
+	should.Equal("stream", obj.Field2)
 	should.Equal("c", obj.Field3)
 	should.Equal("d", obj.Field4)
 	should.Equal("e", obj.Field5)
@@ -322,9 +322,9 @@ func Test_decode_more_than_ten_fields_struct(t *testing.T) {
 	obj := TestObject{}
 	should.Nil(UnmarshalFromString(`{}`, &obj))
 	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field11":1, "Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
+	should.Nil(UnmarshalFromString(`{"Field11":1, "Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
 	should.Equal("a", obj.Field1)
-	should.Equal("b", obj.Field2)
+	should.Equal("stream", obj.Field2)
 	should.Equal("c", obj.Field3)
 	should.Equal("d", obj.Field4)
 	should.Equal("e", obj.Field5)

jsoniter_skip_test.go

@@ -9,90 +9,90 @@ import (
 )
 
 func Test_skip_number(t *testing.T) {
-	iter := ParseString(ConfigDefault, `[-0.12, "b"]`)
+	iter := ParseString(ConfigDefault, `[-0.12, "stream"]`)
 	iter.ReadArray()
 	iter.Skip()
 	iter.ReadArray()
-	if iter.ReadString() != "b" {
+	if iter.ReadString() != "stream" {
 		t.FailNow()
 	}
 
 }
 
 func Test_skip_null(t *testing.T) {
-	iter := ParseString(ConfigDefault, `[null , "b"]`)
+	iter := ParseString(ConfigDefault, `[null , "stream"]`)
 	iter.ReadArray()
 	iter.Skip()
 	iter.ReadArray()
-	if iter.ReadString() != "b" {
+	if iter.ReadString() != "stream" {
 		t.FailNow()
 	}
 }
 
 func Test_skip_true(t *testing.T) {
-	iter := ParseString(ConfigDefault, `[true , "b"]`)
+	iter := ParseString(ConfigDefault, `[true , "stream"]`)
 	iter.ReadArray()
 	iter.Skip()
 	iter.ReadArray()
-	if iter.ReadString() != "b" {
+	if iter.ReadString() != "stream" {
 		t.FailNow()
 	}
 }
 
 func Test_skip_false(t *testing.T) {
-	iter := ParseString(ConfigDefault, `[false , "b"]`)
+	iter := ParseString(ConfigDefault, `[false , "stream"]`)
 	iter.ReadArray()
 	iter.Skip()
 	iter.ReadArray()
-	if iter.ReadString() != "b" {
+	if iter.ReadString() != "stream" {
 		t.FailNow()
 	}
 }
 
 func Test_skip_array(t *testing.T) {
-	iter := ParseString(ConfigDefault, `[[1, [2, [3], 4]], "b"]`)
+	iter := ParseString(ConfigDefault, `[[1, [2, [3], 4]], "stream"]`)
 	iter.ReadArray()
 	iter.Skip()
 	iter.ReadArray()
-	if iter.ReadString() != "b" {
+	if iter.ReadString() != "stream" {
 		t.FailNow()
 	}
 }
 
 func Test_skip_empty_array(t *testing.T) {
-	iter := ParseString(ConfigDefault, `[ [ ], "b"]`)
+	iter := ParseString(ConfigDefault, `[ [ ], "stream"]`)
 	iter.ReadArray()
 	iter.Skip()
 	iter.ReadArray()
-	if iter.ReadString() != "b" {
+	if iter.ReadString() != "stream" {
 		t.FailNow()
 	}
 }
 
 func Test_skip_nested(t *testing.T) {
-	iter := ParseString(ConfigDefault, `[ {"a" : [{"b": "c"}], "d": 102 }, "b"]`)
+	iter := ParseString(ConfigDefault, `[ {"a" : [{"stream": "c"}], "d": 102 }, "stream"]`)
 	iter.ReadArray()
 	iter.Skip()
 	iter.ReadArray()
-	if iter.ReadString() != "b" {
+	if iter.ReadString() != "stream" {
 		t.FailNow()
 	}
 }
 
 func Test_skip_and_return_bytes(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigDefault, `[ {"a" : [{"b": "c"}], "d": 102 }, "b"]`)
+	iter := ParseString(ConfigDefault, `[ {"a" : [{"stream": "c"}], "d": 102 }, "stream"]`)
 	iter.ReadArray()
 	skipped := iter.SkipAndReturnBytes()
-	should.Equal(`{"a" : [{"b": "c"}], "d": 102 }`, string(skipped))
+	should.Equal(`{"a" : [{"stream": "c"}], "d": 102 }`, string(skipped))
 }
 
 func Test_skip_and_return_bytes_with_reader(t *testing.T) {
 	should := require.New(t)
-	iter := Parse(ConfigDefault, bytes.NewBufferString(`[ {"a" : [{"b": "c"}], "d": 102 }, "b"]`), 4)
+	iter := Parse(ConfigDefault, bytes.NewBufferString(`[ {"a" : [{"stream": "c"}], "d": 102 }, "stream"]`), 4)
 	iter.ReadArray()
 	skipped := iter.SkipAndReturnBytes()
-	should.Equal(`{"a" : [{"b": "c"}], "d": 102 }`, string(skipped))
+	should.Equal(`{"a" : [{"stream": "c"}], "d": 102 }`, string(skipped))
 }
 
 type TestResp struct {

output_tests/json_marshal/struct/types.go

@@ -46,7 +46,7 @@ func (m *marshalerForTest) UnmarshalJSON(text []byte) error {
 	return nil
 }
 
-var _ json.Marshaler = Marshaler{}
-var _ json.Unmarshaler = &Marshaler{}
+var _ json.Marshaler = marshalerForTest{}
+var _ json.Unmarshaler = &marshalerForTest{}
 
 type typeForTest marshalerForTest

output_tests/json_marshal/struct_field/types.go

@@ -46,11 +46,11 @@ func (m *marshalerForTest) UnmarshalJSON(text []byte) error {
 	return nil
 }
 
-var _ json.Marshaler = Marshaler{}
-var _ json.Unmarshaler = &Marshaler{}
+var _ json.Marshaler = marshalerForTest{}
+var _ json.Unmarshaler = &marshalerForTest{}
 
 type typeForTest struct {
 	S string
-	M Marshaler
+	M marshalerForTest
 	I int8
 }

output_tests/struct/anonymous/no_overlap/json_marshal/types.go

@@ -7,7 +7,8 @@ import (
 	"strings"
 )
 
-type marshalerForTest string
+// MarshalerForTest TEST ONLY
+type MarshalerForTest string
 
 func encode(str string) string {
 	buf := bytes.Buffer{}
@@ -35,20 +36,20 @@ func decode(str string) string {
 	return string(bs)
 }
 
-func (m marshalerForTest) MarshalJSON() ([]byte, error) {
+func (m MarshalerForTest) MarshalJSON() ([]byte, error) {
 	return []byte(`"MANUAL__` + encode(string(m)) + `"`), nil
 }
 
-func (m *marshalerForTest) UnmarshalJSON(text []byte) error {
-	*m = marshalerForTest(decode(strings.TrimPrefix(strings.Trim(string(text), `"`), "MANUAL__")))
+func (m *MarshalerForTest) UnmarshalJSON(text []byte) error {
+	*m = MarshalerForTest(decode(strings.TrimPrefix(strings.Trim(string(text), `"`), "MANUAL__")))
 	return nil
 }
 
-var _ json.Marshaler = *new(marshalerForTest)
-var _ json.Unmarshaler = new(marshalerForTest)
+var _ json.Marshaler = *new(MarshalerForTest)
+var _ json.Unmarshaler = new(MarshalerForTest)
 
 type typeForTest struct {
 	F1 float64
-	Marshaler
+	MarshalerForTest
 	F2 int32
 }

output_tests/struct/anonymous/no_overlap/text_marshal/types.go

@@ -7,7 +7,8 @@ import (
 	"strings"
 )
 
-type marshalerForTest string
+// MarshalerForTest TEST ONLY
+type MarshalerForTest string
 
 func encode(str string) string {
 	buf := bytes.Buffer{}
@@ -35,20 +36,20 @@ func decode(str string) string {
 	return string(bs)
 }
 
-func (m marshalerForTest) MarshalText() ([]byte, error) {
+func (m MarshalerForTest) MarshalText() ([]byte, error) {
 	return []byte(`MANUAL__` + encode(string(m))), nil
 }
 
-func (m *marshalerForTest) UnmarshalText(text []byte) error {
-	*m = marshalerForTest(decode(strings.TrimPrefix(string(text), "MANUAL__")))
+func (m *MarshalerForTest) UnmarshalText(text []byte) error {
+	*m = MarshalerForTest(decode(strings.TrimPrefix(string(text), "MANUAL__")))
 	return nil
 }
 
-var _ encoding.TextMarshaler = *new(marshalerForTest)
-var _ encoding.TextUnmarshaler = new(marshalerForTest)
+var _ encoding.TextMarshaler = *new(MarshalerForTest)
+var _ encoding.TextUnmarshaler = new(MarshalerForTest)
 
 type typeForTest struct {
 	F1 float64
-	Marshaler
+	MarshalerForTest
 	F2 int32
 }