gofmt

feature_adapter.go

@@ -2,11 +2,11 @@ package jsoniter
 
 import (
 	"bytes"
+	"encoding/json"
+	"errors"
 	"io"
 	"reflect"
-	"errors"
 	"unsafe"
-	"encoding/json"
 )
 
 // Unmarshal adapts to json/encoding Unmarshal API

feature_any_array.go

@@ -1,9 +1,9 @@
 package jsoniter
 
 import (
-	"unsafe"
 	"fmt"
 	"reflect"
+	"unsafe"
 )
 
 type arrayLazyAny struct {
@@ -44,7 +44,7 @@ func (any *arrayLazyAny) fillCacheUntil(target int) Any {
 		return any.cache[target]
 	}
 	iter := any.Parse()
-	if (len(any.remaining) == len(any.buf)) {
+	if len(any.remaining) == len(any.buf) {
 		iter.head++
 		c := iter.nextToken()
 		if c != ']' {

feature_any_float.go

@@ -2,8 +2,8 @@ package jsoniter
 
 import (
 	"io"
-	"unsafe"
 	"strconv"
+	"unsafe"
 )
 
 type float64LazyAny struct {

feature_any_int64.go

@@ -2,8 +2,8 @@ package jsoniter
 
 import (
 	"io"
-	"unsafe"
 	"strconv"
+	"unsafe"
 )
 
 type int64LazyAny struct {

feature_any_object.go

@@ -1,9 +1,9 @@
 package jsoniter
 
 import (
-	"unsafe"
 	"fmt"
 	"reflect"
+	"unsafe"
 )
 
 type objectLazyAny struct {

feature_any_string.go

@@ -5,7 +5,7 @@ import (
 	"strconv"
 )
 
-type stringLazyAny struct{
+type stringLazyAny struct {
 	baseAny
 	buf   []byte
 	iter  *Iterator
@@ -136,7 +136,7 @@ func (any *stringLazyAny) GetInterface() interface{} {
 	return any.cache
 }
 
-type stringAny struct{
+type stringAny struct {
 	baseAny
 	err error
 	val string
@@ -146,7 +146,6 @@ func (any *stringAny) Parse() *Iterator {
 	return nil
 }
 
-
 func (any *stringAny) ValueType() ValueType {
 	return String
 }

feature_any_uint64.go

@@ -1,12 +1,11 @@
 package jsoniter
 
 import (
+	"io"
 	"strconv"
 	"unsafe"
-	"io"
 )
 
-
 type uint64LazyAny struct {
 	baseAny
 	buf   []byte

feature_iter.go

@@ -276,4 +276,3 @@ func (iter *Iterator) ReadBase64() (ret []byte) {
 	}
 	return ret[:n]
 }
-

feature_iter_array.go

@@ -18,12 +18,11 @@ func (iter *Iterator) ReadArray() (ret bool) {
 	case ',':
 		return true
 	default:
-		iter.reportError("ReadArray", "expect [ or , or ] or n, but found: " + string([]byte{c}))
+		iter.reportError("ReadArray", "expect [ or , or ] or n, but found: "+string([]byte{c}))
 		return
 	}
 }
 
-
 func (iter *Iterator) ReadArrayCB(callback func(*Iterator) bool) (ret bool) {
 	c := iter.nextToken()
 	if c == '[' {
@@ -46,6 +45,6 @@ func (iter *Iterator) ReadArrayCB(callback func(*Iterator) bool) (ret bool) {
 		iter.skipFixedBytes(3)
 		return true // null
 	}
-	iter.reportError("ReadArrayCB", "expect [ or n, but found: " + string([]byte{c}))
+	iter.reportError("ReadArrayCB", "expect [ or n, but found: "+string([]byte{c}))
 	return false
 }

feature_iter_float.go

@@ -2,12 +2,13 @@ package jsoniter
 
 import (
 	"io"
+	"math/big"
 	"strconv"
 	"unsafe"
-	"math/big"
 )
 
 var floatDigits []int8
+
 const invalidCharForNumber = int8(-1)
 const endOfNumber = int8(-2)
 const dotInNumber = int8(-3)
@@ -75,7 +76,7 @@ func (iter *Iterator) readPositiveFloat32() (ret float32) {
 	value := uint64(0)
 	c := byte(' ')
 	i := iter.head
-	non_decimal_loop:
+non_decimal_loop:
 	for ; i < iter.tail; i++ {
 		c = iter.buf[i]
 		ind := floatDigits[c]
@@ -91,14 +92,14 @@ func (iter *Iterator) readPositiveFloat32() (ret float32) {
 		if value > uint64SafeToMultiple10 {
 			return iter.readFloat32SlowPath()
 		}
-		value = (value << 3) + (value << 1) + uint64(ind); // value = value * 10 + ind;
+		value = (value << 3) + (value << 1) + uint64(ind) // value = value * 10 + ind;
 	}
 	if c == '.' {
 		i++
-		decimalPlaces := 0;
+		decimalPlaces := 0
 		for ; i < iter.tail; i++ {
 			c = iter.buf[i]
-			ind := floatDigits[c];
+			ind := floatDigits[c]
 			switch ind {
 			case endOfNumber:
 				if decimalPlaces > 0 && decimalPlaces < len(POW10) {
@@ -125,7 +126,7 @@ func (iter *Iterator) readPositiveFloat32() (ret float32) {
 func (iter *Iterator) readNumberAsString() (ret string) {
 	strBuf := [16]byte{}
 	str := strBuf[0:0]
-	load_loop:
+load_loop:
 	for {
 		for i := iter.head; i < iter.tail; i++ {
 			c := iter.buf[i]
@@ -178,7 +179,7 @@ func (iter *Iterator) readPositiveFloat64() (ret float64) {
 	value := uint64(0)
 	c := byte(' ')
 	i := iter.head
-	non_decimal_loop:
+non_decimal_loop:
 	for ; i < iter.tail; i++ {
 		c = iter.buf[i]
 		ind := floatDigits[c]
@@ -194,14 +195,14 @@ func (iter *Iterator) readPositiveFloat64() (ret float64) {
 		if value > uint64SafeToMultiple10 {
 			return iter.readFloat64SlowPath()
 		}
-		value = (value << 3) + (value << 1) + uint64(ind); // value = value * 10 + ind;
+		value = (value << 3) + (value << 1) + uint64(ind) // value = value * 10 + ind;
 	}
 	if c == '.' {
 		i++
-		decimalPlaces := 0;
+		decimalPlaces := 0
 		for ; i < iter.tail; i++ {
 			c = iter.buf[i]
-			ind := floatDigits[c];
+			ind := floatDigits[c]
 			switch ind {
 			case endOfNumber:
 				if decimalPlaces > 0 && decimalPlaces < len(POW10) {

feature_iter_int.go

@@ -6,8 +6,8 @@ import (
 
 var intDigits []int8
 
-const uint32SafeToMultiply10 = uint32(0xffffffff) / 10 - 1
-const uint64SafeToMultiple10 = uint64(0xffffffffffffffff) / 10 - 1
+const uint32SafeToMultiply10 = uint32(0xffffffff)/10 - 1
+const uint64SafeToMultiple10 = uint64(0xffffffffffffffff)/10 - 1
 const int64Max = uint64(0x7fffffffffffffff)
 const int32Max = uint32(0x7fffffff)
 const int16Max = uint32(0x7fff)
@@ -37,15 +37,15 @@ func (iter *Iterator) ReadInt8() (ret int8) {
 	c := iter.nextToken()
 	if c == '-' {
 		val := iter.readUint32(iter.readByte())
-		if val > int8Max + 1 {
-			iter.reportError("ReadInt8", "overflow: " + strconv.FormatInt(int64(val), 10))
+		if val > int8Max+1 {
+			iter.reportError("ReadInt8", "overflow: "+strconv.FormatInt(int64(val), 10))
 			return
 		}
 		return -int8(val)
 	} else {
 		val := iter.readUint32(c)
 		if val > int8Max {
-			iter.reportError("ReadInt8", "overflow: " + strconv.FormatInt(int64(val), 10))
+			iter.reportError("ReadInt8", "overflow: "+strconv.FormatInt(int64(val), 10))
 			return
 		}
 		return int8(val)
@@ -55,7 +55,7 @@ func (iter *Iterator) ReadInt8() (ret int8) {
 func (iter *Iterator) ReadUint8() (ret uint8) {
 	val := iter.readUint32(iter.nextToken())
 	if val > uint8Max {
-		iter.reportError("ReadUint8", "overflow: " + strconv.FormatInt(int64(val), 10))
+		iter.reportError("ReadUint8", "overflow: "+strconv.FormatInt(int64(val), 10))
 		return
 	}
 	return uint8(val)
@@ -65,15 +65,15 @@ func (iter *Iterator) ReadInt16() (ret int16) {
 	c := iter.nextToken()
 	if c == '-' {
 		val := iter.readUint32(iter.readByte())
-		if val > int16Max + 1 {
-			iter.reportError("ReadInt16", "overflow: " + strconv.FormatInt(int64(val), 10))
+		if val > int16Max+1 {
+			iter.reportError("ReadInt16", "overflow: "+strconv.FormatInt(int64(val), 10))
 			return
 		}
 		return -int16(val)
 	} else {
 		val := iter.readUint32(c)
 		if val > int16Max {
-			iter.reportError("ReadInt16", "overflow: " + strconv.FormatInt(int64(val), 10))
+			iter.reportError("ReadInt16", "overflow: "+strconv.FormatInt(int64(val), 10))
 			return
 		}
 		return int16(val)
@@ -83,7 +83,7 @@ func (iter *Iterator) ReadInt16() (ret int16) {
 func (iter *Iterator) ReadUint16() (ret uint16) {
 	val := iter.readUint32(iter.nextToken())
 	if val > uint16Max {
-		iter.reportError("ReadUint16", "overflow: " + strconv.FormatInt(int64(val), 10))
+		iter.reportError("ReadUint16", "overflow: "+strconv.FormatInt(int64(val), 10))
 		return
 	}
 	return uint16(val)
@@ -93,15 +93,15 @@ func (iter *Iterator) ReadInt32() (ret int32) {
 	c := iter.nextToken()
 	if c == '-' {
 		val := iter.readUint32(iter.readByte())
-		if val > int32Max + 1 {
-			iter.reportError("ReadInt32", "overflow: " + strconv.FormatInt(int64(val), 10))
+		if val > int32Max+1 {
+			iter.reportError("ReadInt32", "overflow: "+strconv.FormatInt(int64(val), 10))
 			return
 		}
 		return -int32(val)
 	} else {
 		val := iter.readUint32(c)
 		if val > int32Max {
-			iter.reportError("ReadInt32", "overflow: " + strconv.FormatInt(int64(val), 10))
+			iter.reportError("ReadInt32", "overflow: "+strconv.FormatInt(int64(val), 10))
 			return
 		}
 		return int32(val)
@@ -118,11 +118,11 @@ func (iter *Iterator) readUint32(c byte) (ret uint32) {
 		return 0 // single zero
 	}
 	if ind == invalidCharForNumber {
-		iter.reportError("readUint32", "unexpected character: " + string([]byte{byte(ind)}))
+		iter.reportError("readUint32", "unexpected character: "+string([]byte{byte(ind)}))
 		return
 	}
 	value := uint32(ind)
-	if iter.tail - iter.head > 10 {
+	if iter.tail-iter.head > 10 {
 		i := iter.head
 		ind2 := intDigits[iter.buf[i]]
 		if ind2 == invalidCharForNumber {
@@ -133,7 +133,7 @@ func (iter *Iterator) readUint32(c byte) (ret uint32) {
 		ind3 := intDigits[iter.buf[i]]
 		if ind3 == invalidCharForNumber {
 			iter.head = i
-			return value * 10 + uint32(ind2)
+			return value*10 + uint32(ind2)
 		}
 		//iter.head = i + 1
 		//value = value * 100 + uint32(ind2) * 10 + uint32(ind3)
@@ -141,35 +141,35 @@ func (iter *Iterator) readUint32(c byte) (ret uint32) {
 		ind4 := intDigits[iter.buf[i]]
 		if ind4 == invalidCharForNumber {
 			iter.head = i
-			return value * 100 + uint32(ind2) * 10 + uint32(ind3)
+			return value*100 + uint32(ind2)*10 + uint32(ind3)
 		}
 		i++
 		ind5 := intDigits[iter.buf[i]]
 		if ind5 == invalidCharForNumber {
 			iter.head = i
-			return value * 1000 + uint32(ind2) * 100 + uint32(ind3) * 10 + uint32(ind4)
+			return value*1000 + uint32(ind2)*100 + uint32(ind3)*10 + uint32(ind4)
 		}
 		i++
 		ind6 := intDigits[iter.buf[i]]
 		if ind6 == invalidCharForNumber {
 			iter.head = i
-			return value * 10000 + uint32(ind2) * 1000 + uint32(ind3) * 100 + uint32(ind4) * 10 + uint32(ind5)
+			return value*10000 + uint32(ind2)*1000 + uint32(ind3)*100 + uint32(ind4)*10 + uint32(ind5)
 		}
 		i++
 		ind7 := intDigits[iter.buf[i]]
 		if ind7 == invalidCharForNumber {
 			iter.head = i
-			return value * 100000 + uint32(ind2) * 10000 + uint32(ind3) * 1000 + uint32(ind4) * 100 + uint32(ind5) * 10 + uint32(ind6)
+			return value*100000 + uint32(ind2)*10000 + uint32(ind3)*1000 + uint32(ind4)*100 + uint32(ind5)*10 + uint32(ind6)
 		}
 		i++
 		ind8 := intDigits[iter.buf[i]]
 		if ind8 == invalidCharForNumber {
 			iter.head = i
-			return value * 1000000 + uint32(ind2) * 100000 + uint32(ind3) * 10000 + uint32(ind4) * 1000 + uint32(ind5) * 100 + uint32(ind6) * 10 + uint32(ind7)
+			return value*1000000 + uint32(ind2)*100000 + uint32(ind3)*10000 + uint32(ind4)*1000 + uint32(ind5)*100 + uint32(ind6)*10 + uint32(ind7)
 		}
 		i++
 		ind9 := intDigits[iter.buf[i]]
-		value = value * 10000000 + uint32(ind2) * 1000000 + uint32(ind3) * 100000 + uint32(ind4) * 10000 + uint32(ind5) * 1000 + uint32(ind6) * 100 + uint32(ind7) * 10 + uint32(ind8)
+		value = value*10000000 + uint32(ind2)*1000000 + uint32(ind3)*100000 + uint32(ind4)*10000 + uint32(ind5)*1000 + uint32(ind6)*100 + uint32(ind7)*10 + uint32(ind8)
 		iter.head = i
 		if ind9 == invalidCharForNumber {
 			return value
@@ -194,7 +194,7 @@ func (iter *Iterator) readUint32(c byte) (ret uint32) {
 			}
 			value = (value << 3) + (value << 1) + uint32(ind)
 		}
-		if (!iter.loadMore()) {
+		if !iter.loadMore() {
 			return value
 		}
 	}
@@ -204,15 +204,15 @@ func (iter *Iterator) ReadInt64() (ret int64) {
 	c := iter.nextToken()
 	if c == '-' {
 		val := iter.readUint64(iter.readByte())
-		if val > int64Max + 1 {
-			iter.reportError("ReadInt64", "overflow: " + strconv.FormatUint(uint64(val), 10))
+		if val > int64Max+1 {
+			iter.reportError("ReadInt64", "overflow: "+strconv.FormatUint(uint64(val), 10))
 			return
 		}
 		return -int64(val)
 	} else {
 		val := iter.readUint64(c)
 		if val > int64Max {
-			iter.reportError("ReadInt64", "overflow: " + strconv.FormatUint(uint64(val), 10))
+			iter.reportError("ReadInt64", "overflow: "+strconv.FormatUint(uint64(val), 10))
 			return
 		}
 		return int64(val)
@@ -229,7 +229,7 @@ func (iter *Iterator) readUint64(c byte) (ret uint64) {
 		return 0 // single zero
 	}
 	if ind == invalidCharForNumber {
-		iter.reportError("readUint64", "unexpected character: " + string([]byte{byte(ind)}))
+		iter.reportError("readUint64", "unexpected character: "+string([]byte{byte(ind)}))
 		return
 	}
 	value := uint64(ind)
@@ -252,7 +252,7 @@ func (iter *Iterator) readUint64(c byte) (ret uint64) {
 			}
 			value = (value << 3) + (value << 1) + uint64(ind)
 		}
-		if (!iter.loadMore()) {
+		if !iter.loadMore() {
 			return value
 		}
 	}

feature_iter_object.go

@@ -44,10 +44,10 @@ func (iter *Iterator) readFieldHash() int32 {
 					b += 'a' - 'A'
 				}
 				if b == '"' {
-					iter.head = i+1
+					iter.head = i + 1
 					c = iter.nextToken()
 					if c != ':' {
-						iter.reportError("readFieldHash", `expect :, but found ` + string([]byte{c}))
+						iter.reportError("readFieldHash", `expect :, but found `+string([]byte{c}))
 					}
 					return int32(hash)
 				}
@@ -60,7 +60,7 @@ func (iter *Iterator) readFieldHash() int32 {
 			}
 		}
 	}
-	iter.reportError("readFieldHash", `expect ", but found ` + string([]byte{c}))
+	iter.reportError("readFieldHash", `expect ", but found `+string([]byte{c}))
 	return 0
 }
 

feature_iter_skip.go

@@ -29,7 +29,6 @@ func (iter *Iterator) ReadBool() (ret bool) {
 	return
 }
 
-
 func (iter *Iterator) SkipAndReturnBytes() []byte {
 	if iter.reader != nil {
 		panic("reader input does not support this api")
@@ -40,7 +39,6 @@ func (iter *Iterator) SkipAndReturnBytes() []byte {
 	return iter.buf[before:after]
 }
 
-
 // Skip skips a json object and positions to relatively the next json object
 func (iter *Iterator) Skip() {
 	c := iter.nextToken()
@@ -204,15 +202,15 @@ func (iter *Iterator) skipUntilBreak() {
 }
 
 func (iter *Iterator) skipFixedBytes(n int) {
-	iter.head += n;
-	if (iter.head >= iter.tail) {
-		more := iter.head - iter.tail;
+	iter.head += n
+	if iter.head >= iter.tail {
+		more := iter.head - iter.tail
 		if !iter.loadMore() {
 			if more > 0 {
-				iter.reportError("skipFixedBytes", "unexpected end");
+				iter.reportError("skipFixedBytes", "unexpected end")
 			}
 			return
 		}
-		iter.head += more;
+		iter.head += more
 	}
 }

feature_iter_string.go

@@ -7,7 +7,7 @@ import (
 func (iter *Iterator) ReadString() (ret string) {
 	c := iter.nextToken()
 	if c == '"' {
-		for i := iter.head ; i < iter.tail; i++ {
+		for i := iter.head; i < iter.tail; i++ {
 			c := iter.buf[i]
 			if c == '"' {
 				ret = string(iter.buf[iter.head:i])
@@ -103,13 +103,13 @@ func (iter *Iterator) ReadStringAsSlice() (ret []byte) {
 			// for: field name, base64, number
 			if iter.buf[i] == '"' {
 				// fast path: reuse the underlying buffer
-				ret = iter.buf[iter.head : i]
+				ret = iter.buf[iter.head:i]
 				iter.head = i + 1
 				return ret
 			}
 		}
 		readLen := iter.tail - iter.head
-		copied := make([]byte, readLen, readLen * 2)
+		copied := make([]byte, readLen, readLen*2)
 		copy(copied, iter.buf[iter.head:iter.tail])
 		iter.head = iter.tail
 		for iter.Error == nil {
@@ -132,11 +132,11 @@ func (iter *Iterator) readU4() (ret rune) {
 			return
 		}
 		if c >= '0' && c <= '9' {
-			ret = ret * 16 + rune(c - '0')
+			ret = ret*16 + rune(c-'0')
 		} else if c >= 'a' && c <= 'f' {
-			ret = ret * 16 + rune(c - 'a' + 10)
+			ret = ret*16 + rune(c-'a'+10)
 		} else if c >= 'A' && c <= 'F' {
-			ret = ret * 16 + rune(c - 'A' + 10)
+			ret = ret*16 + rune(c-'A'+10)
 		} else {
 			iter.reportError("readU4", "expects 0~9 or a~f")
 			return
@@ -158,9 +158,9 @@ const (
 	mask3 = 0x0F // 0000 1111
 	mask4 = 0x07 // 0000 0111
 
-	rune1Max = 1 << 7 - 1
-	rune2Max = 1 << 11 - 1
-	rune3Max = 1 << 16 - 1
+	rune1Max = 1<<7 - 1
+	rune2Max = 1<<11 - 1
+	rune3Max = 1<<16 - 1
 
 	surrogateMin = 0xD800
 	surrogateMax = 0xDFFF
@@ -176,22 +176,22 @@ func appendRune(p []byte, r rune) []byte {
 		p = append(p, byte(r))
 		return p
 	case i <= rune2Max:
-		p = append(p, t2 | byte(r >> 6))
-		p = append(p, tx | byte(r) & maskx)
+		p = append(p, t2|byte(r>>6))
+		p = append(p, tx|byte(r)&maskx)
 		return p
 	case i > maxRune, surrogateMin <= i && i <= surrogateMax:
 		r = runeError
 		fallthrough
 	case i <= rune3Max:
-		p = append(p, t3 | byte(r >> 12))
-		p = append(p, tx | byte(r >> 6) & maskx)
-		p = append(p, tx | byte(r) & maskx)
+		p = append(p, t3|byte(r>>12))
+		p = append(p, tx|byte(r>>6)&maskx)
+		p = append(p, tx|byte(r)&maskx)
 		return p
 	default:
-		p = append(p, t4 | byte(r >> 18))
-		p = append(p, tx | byte(r >> 12) & maskx)
-		p = append(p, tx | byte(r >> 6) & maskx)
-		p = append(p, tx | byte(r) & maskx)
+		p = append(p, t4|byte(r>>18))
+		p = append(p, tx|byte(r>>12)&maskx)
+		p = append(p, tx|byte(r>>6)&maskx)
+		p = append(p, tx|byte(r)&maskx)
 		return p
 	}
 }

feature_reflect.go

@@ -1,12 +1,12 @@
 package jsoniter
 
 import (
+	"encoding"
+	"encoding/json"
 	"fmt"
 	"reflect"
 	"sync/atomic"
 	"unsafe"
-	"encoding/json"
-	"encoding"
 )
 
 /*

feature_reflect_array.go

@@ -1,10 +1,10 @@
 package jsoniter
 
 import (
-	"unsafe"
-	"reflect"
-	"io"
 	"fmt"
+	"io"
+	"reflect"
+	"unsafe"
 )
 
 func decoderOfSlice(typ reflect.Type) (Decoder, error) {
@@ -21,7 +21,7 @@ func encoderOfSlice(typ reflect.Type) (Encoder, error) {
 		return nil, err
 	}
 	if typ.Elem().Kind() == reflect.Map {
-		encoder = &optionalEncoder{ encoder}
+		encoder = &optionalEncoder{encoder}
 	}
 	return &sliceEncoder{typ, typ.Elem(), encoder}, nil
 }
@@ -88,30 +88,30 @@ func (decoder *sliceDecoder) doDecode(ptr unsafe.Pointer, iter *Iterator) {
 		return
 	}
 	offset := uintptr(0)
-	decoder.elemDecoder.decode(unsafe.Pointer(uintptr(slice.Data) + offset), iter)
+	decoder.elemDecoder.decode(unsafe.Pointer(uintptr(slice.Data)+offset), iter)
 	if !iter.ReadArray() {
 		slice.Len = 1
 		return
 	}
 	offset += decoder.elemType.Size()
-	decoder.elemDecoder.decode(unsafe.Pointer(uintptr(slice.Data) + offset), iter)
+	decoder.elemDecoder.decode(unsafe.Pointer(uintptr(slice.Data)+offset), iter)
 	if !iter.ReadArray() {
 		slice.Len = 2
 		return
 	}
 	offset += decoder.elemType.Size()
-	decoder.elemDecoder.decode(unsafe.Pointer(uintptr(slice.Data) + offset), iter)
+	decoder.elemDecoder.decode(unsafe.Pointer(uintptr(slice.Data)+offset), iter)
 	if !iter.ReadArray() {
 		slice.Len = 3
 		return
 	}
 	offset += decoder.elemType.Size()
-	decoder.elemDecoder.decode(unsafe.Pointer(uintptr(slice.Data) + offset), iter)
+	decoder.elemDecoder.decode(unsafe.Pointer(uintptr(slice.Data)+offset), iter)
 	slice.Len = 4
 	for iter.ReadArray() {
 		growOne(slice, decoder.sliceType, decoder.elemType)
 		offset += decoder.elemType.Size()
-		decoder.elemDecoder.decode(unsafe.Pointer(uintptr(slice.Data) + offset), iter)
+		decoder.elemDecoder.decode(unsafe.Pointer(uintptr(slice.Data)+offset), iter)
 	}
 }
 

feature_reflect_map.go

@@ -1,11 +1,11 @@
 package jsoniter
 
 import (
-	"unsafe"
-	"reflect"
-	"encoding/json"
 	"encoding"
+	"encoding/json"
+	"reflect"
 	"strconv"
+	"unsafe"
 )
 
 type mapDecoder struct {

feature_reflect_native.go

@@ -1,9 +1,9 @@
 package jsoniter
 
 import (
-	"unsafe"
-	"encoding/json"
 	"encoding/base64"
+	"encoding/json"
+	"unsafe"
 )
 
 type stringCodec struct {
@@ -386,7 +386,7 @@ type base64Codec struct {
 func (codec *base64Codec) decode(ptr unsafe.Pointer, iter *Iterator) {
 	encoding := base64.StdEncoding
 	src := iter.SkipAndReturnBytes()
-	src = src[1:len(src)-1]
+	src = src[1 : len(src)-1]
 	decodedLen := encoding.DecodedLen(len(src))
 	dst := make([]byte, decodedLen)
 	_, err := encoding.Decode(dst, src)

feature_reflect_object.go

@@ -1,12 +1,12 @@
 package jsoniter
 
 import (
-	"io"
 	"fmt"
+	"io"
 	"reflect"
-	"unsafe"
 	"strings"
 	"unicode"
+	"unsafe"
 )
 
 func encoderOfStruct(typ reflect.Type) (Encoder, error) {
@@ -138,7 +138,7 @@ func EnableUnexportedStructFieldsSupport() {
 
 func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder) (Decoder, error) {
 	knownHash := map[int32]struct{}{
-		0: struct{}{},
+		0: {},
 	}
 	switch len(fields) {
 	case 0:

feature_stream.go

@@ -319,8 +319,8 @@ func (stream *Stream) writeIndention(delta int) {
 	stream.writeByte('\n')
 	toWrite := stream.indention - delta
 	stream.ensure(toWrite)
-	for i := 0 ; i < toWrite && stream.n < len(stream.buf); i++ {
+	for i := 0; i < toWrite && stream.n < len(stream.buf); i++ {
 		stream.buf[stream.n] = ' '
-		stream.n ++
+		stream.n++
 	}
 }

feature_stream_float.go

@@ -21,12 +21,12 @@ func (stream *Stream) WriteFloat32Lossy(val float32) {
 		val = -val
 	}
 	if val > 0x4ffffff {
-		stream.WriteRaw(strconv.FormatFloat(float64(val), 'f', -1, 32));
+		stream.WriteRaw(strconv.FormatFloat(float64(val), 'f', -1, 32))
 		return
 	}
 	precision := 6
 	exp := uint64(1000000) // 6
-	lval := uint64(float64(val) * float64(exp) + 0.5)
+	lval := uint64(float64(val)*float64(exp) + 0.5)
 	stream.WriteUint64(lval / exp)
 	fval := lval % exp
 	if fval == 0 {
@@ -38,7 +38,7 @@ func (stream *Stream) WriteFloat32Lossy(val float32) {
 		stream.writeByte('0')
 	}
 	stream.WriteUint64(fval)
-	for stream.buf[stream.n - 1] == '0' {
+	for stream.buf[stream.n-1] == '0' {
 		stream.n--
 	}
 }
@@ -53,12 +53,12 @@ func (stream *Stream) WriteFloat64Lossy(val float64) {
 		val = -val
 	}
 	if val > 0x4ffffff {
-		stream.WriteRaw(strconv.FormatFloat(val, 'f', -1, 64));
+		stream.WriteRaw(strconv.FormatFloat(val, 'f', -1, 64))
 		return
 	}
 	precision := 6
 	exp := uint64(1000000) // 6
-	lval := uint64(val * float64(exp) + 0.5)
+	lval := uint64(val*float64(exp) + 0.5)
 	stream.WriteUint64(lval / exp)
 	fval := lval % exp
 	if fval == 0 {
@@ -70,7 +70,7 @@ func (stream *Stream) WriteFloat64Lossy(val float64) {
 		stream.writeByte('0')
 	}
 	stream.WriteUint64(fval)
-	for stream.buf[stream.n - 1] == '0' {
+	for stream.buf[stream.n-1] == '0' {
 		stream.n--
 	}
 }

feature_stream_int.go

@@ -5,7 +5,7 @@ var DIGITS []uint32
 func init() {
 	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
 		} else if i < 100 {
@@ -32,8 +32,8 @@ func writeFirstBuf(buf []byte, v uint32, n int) int {
 
 func writeBuf(buf []byte, v uint32, n int) {
 	buf[n] = byte(v >> 16)
-	buf[n + 1] = byte(v >> 8)
-	buf[n + 2] = byte(v)
+	buf[n+1] = byte(v >> 8)
+	buf[n+2] = byte(v)
 }
 
 func (stream *Stream) WriteUint8(val uint8) {
@@ -62,7 +62,7 @@ func (stream *Stream) WriteUint16(val uint16) {
 		stream.n = writeFirstBuf(stream.buf, DIGITS[val], stream.n)
 		return
 	}
-	r1 := val - q1 * 1000
+	r1 := val - q1*1000
 	n := writeFirstBuf(stream.buf, DIGITS[q1], stream.n)
 	writeBuf(stream.buf, DIGITS[r1], n)
 	stream.n = n + 3
@@ -85,7 +85,7 @@ func (stream *Stream) WriteInt16(nval int16) {
 		stream.n = writeFirstBuf(stream.buf, DIGITS[val], n)
 		return
 	}
-	r1 := val - q1 * 1000
+	r1 := val - q1*1000
 	n = writeFirstBuf(stream.buf, DIGITS[q1], n)
 	writeBuf(stream.buf, DIGITS[r1], n)
 	stream.n = n + 3
@@ -100,7 +100,7 @@ func (stream *Stream) WriteUint32(val uint32) {
 		stream.n = writeFirstBuf(stream.buf, DIGITS[val], n)
 		return
 	}
-	r1 := val - q1 * 1000
+	r1 := val - q1*1000
 	q2 := q1 / 1000
 	if q2 == 0 {
 		n := writeFirstBuf(stream.buf, DIGITS[q1], n)
@@ -108,19 +108,19 @@ func (stream *Stream) WriteUint32(val uint32) {
 		stream.n = n + 3
 		return
 	}
-	r2 := q1 - q2 * 1000
+	r2 := q1 - q2*1000
 	q3 := q2 / 1000
 	if q3 == 0 {
 		n = writeFirstBuf(stream.buf, DIGITS[q2], n)
 	} else {
-		r3 := q2 - q3 * 1000
+		r3 := q2 - q3*1000
 		stream.buf[n] = byte(q3 + '0')
 		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[r1], n+3)
 	stream.n = n + 6
 }
 
@@ -128,7 +128,7 @@ func (stream *Stream) WriteInt32(nval int32) {
 	stream.ensure(11)
 	n := stream.n
 	var val uint32
-	if (nval < 0) {
+	if nval < 0 {
 		val = uint32(-nval)
 		stream.buf[n] = '-'
 		n++
@@ -140,7 +140,7 @@ func (stream *Stream) WriteInt32(nval int32) {
 		stream.n = writeFirstBuf(stream.buf, DIGITS[val], n)
 		return
 	}
-	r1 := val - q1 * 1000
+	r1 := val - q1*1000
 	q2 := q1 / 1000
 	if q2 == 0 {
 		n := writeFirstBuf(stream.buf, DIGITS[q1], n)
@@ -148,19 +148,19 @@ func (stream *Stream) WriteInt32(nval int32) {
 		stream.n = n + 3
 		return
 	}
-	r2 := q1 - q2 * 1000
+	r2 := q1 - q2*1000
 	q3 := q2 / 1000
 	if q3 == 0 {
 		n = writeFirstBuf(stream.buf, DIGITS[q2], n)
 	} else {
-		r3 := q2 - q3 * 1000
+		r3 := q2 - q3*1000
 		stream.buf[n] = byte(q3 + '0')
 		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[r1], n+3)
 	stream.n = n + 6
 }
 
@@ -172,7 +172,7 @@ func (stream *Stream) WriteUint64(val uint64) {
 		stream.n = writeFirstBuf(stream.buf, DIGITS[val], n)
 		return
 	}
-	r1 := val - q1 * 1000
+	r1 := val - q1*1000
 	q2 := q1 / 1000
 	if q2 == 0 {
 		n := writeFirstBuf(stream.buf, DIGITS[q1], n)
@@ -180,51 +180,51 @@ func (stream *Stream) WriteUint64(val uint64) {
 		stream.n = n + 3
 		return
 	}
-	r2 := q1 - q2 * 1000
+	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)
+		writeBuf(stream.buf, DIGITS[r1], n+3)
 		stream.n = n + 6
 		return
 	}
-	r3 := q2 - q3 * 1000
+	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)
+		writeBuf(stream.buf, DIGITS[r2], n+3)
+		writeBuf(stream.buf, DIGITS[r1], n+6)
 		stream.n = n + 9
 		return
 	}
-	r4 := q3 - q4 * 1000
+	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)
+		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
+	r5 := q4 - q5*1000
 	q6 := q5 / 1000
 	if q6 == 0 {
 		n = writeFirstBuf(stream.buf, DIGITS[q5], n)
 	} else {
 		n = writeFirstBuf(stream.buf, DIGITS[q6], n)
-		r6 := q5 - q6 * 1000
+		r6 := q5 - q6*1000
 		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[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
 }
 
@@ -232,7 +232,7 @@ func (stream *Stream) WriteInt64(nval int64) {
 	stream.ensure(20)
 	n := stream.n
 	var val uint64
-	if (nval < 0) {
+	if nval < 0 {
 		val = uint64(-nval)
 		stream.buf[n] = '-'
 		n++
@@ -244,7 +244,7 @@ func (stream *Stream) WriteInt64(nval int64) {
 		stream.n = writeFirstBuf(stream.buf, DIGITS[val], n)
 		return
 	}
-	r1 := val - q1 * 1000;
+	r1 := val - q1*1000
 	q2 := q1 / 1000
 	if q2 == 0 {
 		n := writeFirstBuf(stream.buf, DIGITS[q1], n)
@@ -252,52 +252,52 @@ func (stream *Stream) WriteInt64(nval int64) {
 		stream.n = n + 3
 		return
 	}
-	r2 := q1 - q2 * 1000
+	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)
+		writeBuf(stream.buf, DIGITS[r1], n+3)
 		stream.n = n + 6
 		return
 	}
-	r3 := q2 - q3 * 1000
+	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)
+		writeBuf(stream.buf, DIGITS[r2], n+3)
+		writeBuf(stream.buf, DIGITS[r1], n+6)
 		stream.n = n + 9
 		return
 	}
-	r4 := q3 - q4 * 1000
+	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)
+		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
+	r5 := q4 - q5*1000
 	q6 := q5 / 1000
 	if q6 == 0 {
 		n = writeFirstBuf(stream.buf, DIGITS[q5], n)
 	} else {
 		stream.buf[n] = byte(q6 + '0')
 		n++
-		r6 := q5 - q6 * 1000
+		r6 := q5 - q6*1000
 		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[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
 }
 

jsoniter_adapter_test.go

@@ -1,11 +1,11 @@
 package jsoniter
 
 import (
-	"testing"
-	"github.com/json-iterator/go/require"
-	"encoding/json"
 	"bytes"
+	"encoding/json"
+	"github.com/json-iterator/go/require"
 	"io/ioutil"
+	"testing"
 )
 
 func Test_new_decoder(t *testing.T) {

jsoniter_array_test.go

@@ -1,11 +1,11 @@
 package jsoniter
 
 import (
-	"encoding/json"
-	"testing"
-	"github.com/json-iterator/go/require"
 	"bytes"
+	"encoding/json"
+	"github.com/json-iterator/go/require"
 	"io"
+	"testing"
 )
 
 func Test_empty_array(t *testing.T) {
@@ -84,7 +84,7 @@ func Test_read_array_with_any_iterator(t *testing.T) {
 
 func Test_wrap_array(t *testing.T) {
 	should := require.New(t)
-	any := Wrap([]int{1,2,3})
+	any := Wrap([]int{1, 2, 3})
 	should.Equal("[1,2,3]", any.ToString())
 	var element Any
 	var elements []int
@@ -93,9 +93,9 @@ func Test_wrap_array(t *testing.T) {
 		elements = append(elements, element.ToInt())
 	}
 	should.Equal([]int{1, 2, 3}, elements)
-	any = Wrap([]int{1,2,3})
+	any = Wrap([]int{1, 2, 3})
 	should.Equal(3, any.Size())
-	any = Wrap([]int{1,2,3})
+	any = Wrap([]int{1, 2, 3})
 	should.Equal(2, any.Get(1).ToInt())
 }
 
@@ -103,7 +103,7 @@ func Test_array_lazy_any_get(t *testing.T) {
 	should := require.New(t)
 	any, err := UnmarshalAnyFromString("[1,[2,3],4]")
 	should.Nil(err)
-	should.Equal(3, any.Get(1,1).ToInt())
+	should.Equal(3, any.Get(1, 1).ToInt())
 	should.Equal("[1,[2,3],4]", any.ToString())
 }
 
@@ -111,25 +111,25 @@ func Test_array_lazy_any_get_all(t *testing.T) {
 	should := require.New(t)
 	any, err := UnmarshalAnyFromString("[[1],[2],[3,4]]")
 	should.Nil(err)
-	should.Equal("[1,2,3]", any.Get('*',0).ToString())
+	should.Equal("[1,2,3]", any.Get('*', 0).ToString())
 }
 
 func Test_array_wrapper_any_get_all(t *testing.T) {
 	should := require.New(t)
 	any := wrapArray([][]int{
-		[]int{1, 2},
-		[]int{3, 4},
-		[]int{5, 6},
+		{1, 2},
+		{3, 4},
+		{5, 6},
 	})
-	should.Equal("[1,3,5]", any.Get('*',0).ToString())
+	should.Equal("[1,3,5]", any.Get('*', 0).ToString())
 }
 
 func Test_array_lazy_any_get_invalid(t *testing.T) {
 	should := require.New(t)
 	any, err := UnmarshalAnyFromString("[]")
 	should.Nil(err)
-	should.Equal(Invalid, any.Get(1,1).ValueType())
-	should.NotNil(any.Get(1,1).LastError())
+	should.Equal(Invalid, any.Get(1, 1).ValueType())
+	should.NotNil(any.Get(1, 1).LastError())
 	should.Equal(Invalid, any.Get("1").ValueType())
 	should.NotNil(any.Get("1").LastError())
 }
@@ -266,10 +266,10 @@ func Test_json_RawMessage(t *testing.T) {
 
 func Test_encode_byte_array(t *testing.T) {
 	should := require.New(t)
-	bytes, err := json.Marshal([]byte{1,2,3})
+	bytes, err := json.Marshal([]byte{1, 2, 3})
 	should.Nil(err)
 	should.Equal(`"AQID"`, string(bytes))
-	bytes, err = Marshal([]byte{1,2,3})
+	bytes, err = Marshal([]byte{1, 2, 3})
 	should.Nil(err)
 	should.Equal(`"AQID"`, string(bytes))
 }
@@ -279,10 +279,10 @@ func Test_decode_byte_array(t *testing.T) {
 	data := []byte{}
 	err := json.Unmarshal([]byte(`"AQID"`), &data)
 	should.Nil(err)
-	should.Equal([]byte{1,2,3}, data)
+	should.Equal([]byte{1, 2, 3}, data)
 	err = Unmarshal([]byte(`"AQID"`), &data)
 	should.Nil(err)
-	should.Equal([]byte{1,2,3}, data)
+	should.Equal([]byte{1, 2, 3}, data)
 }
 
 func Benchmark_jsoniter_array(b *testing.B) {

jsoniter_bool_test.go

@@ -1,9 +1,9 @@
 package jsoniter
 
 import (
-	"testing"
 	"bytes"
 	"github.com/json-iterator/go/require"
+	"testing"
 )
 
 func Test_true(t *testing.T) {
@@ -38,7 +38,6 @@ func Test_write_true_false(t *testing.T) {
 	should.Equal("truefalse", buf.String())
 }
 
-
 func Test_write_val_bool(t *testing.T) {
 	should := require.New(t)
 	buf := &bytes.Buffer{}

jsoniter_customize_test.go

@@ -1,13 +1,13 @@
 package jsoniter
 
 import (
+	"encoding/json"
+	"github.com/json-iterator/go/require"
 	"reflect"
 	"strconv"
 	"testing"
 	"time"
 	"unsafe"
-	"github.com/json-iterator/go/require"
-	"encoding/json"
 )
 
 func Test_customize_type_decoder(t *testing.T) {

jsoniter_demo_test.go

@@ -1,10 +1,10 @@
 package jsoniter
 
 import (
-	"fmt"
-	"testing"
-	"github.com/json-iterator/go/require"
 	"encoding/json"
+	"fmt"
+	"github.com/json-iterator/go/require"
+	"testing"
 )
 
 func Test_bind_api_demo(t *testing.T) {
@@ -84,4 +84,3 @@ func BenchmarkStdMarshal(b *testing.B) {
 		}
 	}
 }
-

jsoniter_find_end_test.go

@@ -1,9 +1,9 @@
 package jsoniter
 
 import (
+	"github.com/json-iterator/go/require"
 	"io"
 	"testing"
-	"github.com/json-iterator/go/require"
 )
 
 func Test_string_end(t *testing.T) {

jsoniter_float_test.go

@@ -1,12 +1,12 @@
 package jsoniter
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
-	"testing"
 	"github.com/json-iterator/go/require"
-	"bytes"
 	"strconv"
+	"testing"
 )
 
 func Test_read_big_float(t *testing.T) {
@@ -46,14 +46,14 @@ func Test_read_float(t *testing.T) {
 		// streaming
 		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
 			should := require.New(t)
-			iter := Parse(bytes.NewBufferString(input + ","), 2)
+			iter := Parse(bytes.NewBufferString(input+","), 2)
 			expected, err := strconv.ParseFloat(input, 32)
 			should.Nil(err)
 			should.Equal(float32(expected), iter.ReadFloat32())
 		})
 		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
 			should := require.New(t)
-			iter := Parse(bytes.NewBufferString(input + ","), 2)
+			iter := Parse(bytes.NewBufferString(input+","), 2)
 			expected, err := strconv.ParseFloat(input, 64)
 			should.Nil(err)
 			should.Equal(expected, iter.ReadFloat64())

jsoniter_int_test.go

@@ -3,12 +3,12 @@ package jsoniter
 import (
 	"bytes"
 	"encoding/json"
-	"testing"
-	"github.com/json-iterator/go/require"
 	"fmt"
-	"strconv"
-	"io/ioutil"
+	"github.com/json-iterator/go/require"
 	"io"
+	"io/ioutil"
+	"strconv"
+	"testing"
 )
 
 func Test_read_uint64_invalid(t *testing.T) {

jsoniter_interface_test.go

@@ -1,8 +1,8 @@
 package jsoniter
 
 import (
-	"testing"
 	"github.com/json-iterator/go/require"
+	"testing"
 	"unsafe"
 )
 
@@ -16,7 +16,7 @@ func Test_write_array_of_interface(t *testing.T) {
 
 func Test_write_map_of_interface(t *testing.T) {
 	should := require.New(t)
-	val := map[string]interface{}{"hello":"world"}
+	val := map[string]interface{}{"hello": "world"}
 	str, err := MarshalToString(val)
 	should.Nil(err)
 	should.Equal(`{"hello":"world"}`, str)
@@ -27,7 +27,7 @@ func Test_write_map_of_interface_in_struct(t *testing.T) {
 		Field map[string]interface{}
 	}
 	should := require.New(t)
-	val := TestObject{map[string]interface{}{"hello":"world"}}
+	val := TestObject{map[string]interface{}{"hello": "world"}}
 	str, err := MarshalToString(val)
 	should.Nil(err)
 	should.Equal(`{"Field":{"hello":"world"}}`, str)
@@ -39,7 +39,7 @@ func Test_write_map_of_interface_in_struct_with_two_fields(t *testing.T) {
 		Field2 string
 	}
 	should := require.New(t)
-	val := TestObject{map[string]interface{}{"hello":"world"}, ""}
+	val := TestObject{map[string]interface{}{"hello": "world"}, ""}
 	str, err := MarshalToString(val)
 	should.Nil(err)
 	should.Contains(str, `"Field":{"hello":"world"}`)
@@ -59,7 +59,7 @@ func Test_write_map_of_custom_interface(t *testing.T) {
 	should := require.New(t)
 	myStr := MyString("world")
 	should.Equal("world", myStr.Hello())
-	val := map[string]MyInterface{"hello":myStr}
+	val := map[string]MyInterface{"hello": myStr}
 	str, err := MarshalToString(val)
 	should.Nil(err)
 	should.Equal(`{"hello":"world"}`, str)

jsoniter_map_test.go

@@ -1,9 +1,9 @@
 package jsoniter
 
 import (
-	"testing"
 	"github.com/json-iterator/go/require"
 	"math/big"
+	"testing"
 )
 
 func Test_read_map(t *testing.T) {
@@ -41,12 +41,12 @@ func Test_wrap_map(t *testing.T) {
 			vals[k] = v.ToString()
 		}
 	}
-	should.Equal(map[string]string{"Field1":"hello"}, vals)
+	should.Equal(map[string]string{"Field1": "hello"}, vals)
 }
 
 func Test_map_wrapper_any_get_all(t *testing.T) {
 	should := require.New(t)
-	any := Wrap(map[string][]int{"Field1": []int{1, 2}})
+	any := Wrap(map[string][]int{"Field1": {1, 2}})
 	should.Equal(`{"Field1":1}`, any.Get('*', 0).ToString())
 }
 

jsoniter_null_test.go

@@ -1,9 +1,9 @@
 package jsoniter
 
 import (
-	"testing"
-	"github.com/json-iterator/go/require"
 	"bytes"
+	"github.com/json-iterator/go/require"
+	"testing"
 )
 
 func Test_read_null(t *testing.T) {

jsoniter_object_test.go

@@ -1,10 +1,10 @@
 package jsoniter
 
 import (
-	"encoding/json"
-	"testing"
-	"github.com/json-iterator/go/require"
 	"bytes"
+	"encoding/json"
+	"github.com/json-iterator/go/require"
+	"testing"
 )
 
 func Test_empty_object(t *testing.T) {
@@ -100,7 +100,7 @@ func Test_object_any_lazy_iterator(t *testing.T) {
 	should.False(hasNext)
 	vals[k] = v.ToString()
 
-	should.Equal(map[string]string{"a":"b", "c":"d"}, vals)
+	should.Equal(map[string]string{"a": "b", "c": "d"}, vals)
 	vals = map[string]string{}
 	for next, hasNext := any.IterateObject(); hasNext; {
 		k, v, hasNext = next()
@@ -108,7 +108,7 @@ func Test_object_any_lazy_iterator(t *testing.T) {
 			vals[k] = v.ToString()
 		}
 	}
-	should.Equal(map[string]string{"a":"b", "c":"d"}, vals)
+	should.Equal(map[string]string{"a": "b", "c": "d"}, vals)
 }
 
 func Test_object_any_with_two_lazy_iterators(t *testing.T) {
@@ -194,7 +194,7 @@ func Test_wrap_object(t *testing.T) {
 			vals[k] = v.ToString()
 		}
 	}
-	should.Equal(map[string]string{"Field1":"hello"}, vals)
+	should.Equal(map[string]string{"Field1": "hello"}, vals)
 }
 
 func Test_object_wrapper_any_get_all(t *testing.T) {

jsoniter_optional_test.go

@@ -1,8 +1,8 @@
 package jsoniter
 
 import (
-	"testing"
 	"github.com/json-iterator/go/require"
+	"testing"
 )
 
 func Test_encode_optional_int_pointer(t *testing.T) {

jsoniter_reflect_native_test.go

@@ -1,8 +1,8 @@
 package jsoniter
 
 import (
-	"testing"
 	"fmt"
+	"testing"
 )
 
 func Test_reflect_str(t *testing.T) {

jsoniter_reflect_struct_test.go

@@ -1,9 +1,9 @@
 package jsoniter
 
 import (
-	"testing"
-	"github.com/json-iterator/go/require"
 	"bytes"
+	"github.com/json-iterator/go/require"
+	"testing"
 )
 
 func Test_decode_one_field_struct(t *testing.T) {
@@ -230,7 +230,7 @@ func Test_anonymous_struct_marshal(t *testing.T) {
 	type TestObject struct {
 		Field string
 	}
-	str, err := MarshalToString(struct{
+	str, err := MarshalToString(struct {
 		TestObject
 		Field int
 	}{

jsoniter_reflect_test.go

@@ -3,9 +3,9 @@ package jsoniter
 import (
 	"encoding/json"
 	"fmt"
+	"github.com/json-iterator/go/require"
 	"testing"
 	"unsafe"
-	"github.com/json-iterator/go/require"
 )
 
 func Test_decode_slice(t *testing.T) {

jsoniter_stream_test.go

@@ -1,8 +1,8 @@
 package jsoniter
 
 import (
-	"testing"
 	"github.com/json-iterator/go/require"
+	"testing"
 )
 
 func Test_writeByte_should_grow_buffer(t *testing.T) {
@@ -33,7 +33,7 @@ func Test_writeIndention_should_grow_buffer(t *testing.T) {
 	should := require.New(t)
 	stream := NewStream(nil, 1)
 	stream.IndentionStep = 2
-	stream.WriteVal([]int{1,2,3})
+	stream.WriteVal([]int{1, 2, 3})
 	should.Equal("[\n  1,\n  2,\n  3\n]", string(stream.Buffer()))
 }
 

jsoniter_string_test.go

@@ -3,9 +3,9 @@ package jsoniter
 import (
 	"bytes"
 	"encoding/json"
-	"testing"
-	"github.com/json-iterator/go/require"
 	"fmt"
+	"github.com/json-iterator/go/require"
+	"testing"
 )
 
 func Test_read_normal_string(t *testing.T) {