added vendors

vendor/github.com/json-iterator/go/skip_tests/array_test.go

@@ -0,0 +1,15 @@
+package skip_tests
+
+func init() {
+	testCases = append(testCases, testCase{
+		ptr: (*[]interface{})(nil),
+		inputs: []string{
+			`[]`,             // valid
+			`[1]`,            // valid
+			`[  1, "hello"]`, // valid
+			`[abc]`,          // invalid
+			`[`,              // invalid
+			`[[]`,            // invalid
+		},
+	})
+}

vendor/github.com/json-iterator/go/skip_tests/float64_test.go

@@ -0,0 +1,20 @@
+package skip_tests
+
+func init() {
+	testCases = append(testCases, testCase{
+		ptr: (*float64)(nil),
+		inputs: []string{
+			"+1",    // invalid
+			"-a",    // invalid
+			"-\x00", // invalid, zero byte
+			"0.1",   // valid
+			"0..1",  // invalid, more dot
+			"1e+1",  // valid
+			"1+1",   // invalid
+			"1E1",   // valid, e or E
+			"1ee1",  // invalid
+			"100a",  // invalid
+			"10.",   // invalid
+		},
+	})
+}

vendor/github.com/json-iterator/go/skip_tests/jsoniter_skip_test.go

@@ -0,0 +1,185 @@
+package skip_tests
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_skip_number_in_array(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[-0.12, "stream"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	should.Nil(iter.Error)
+	should.Equal("stream", iter.ReadString())
+}
+
+func Test_skip_string_in_array(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `["hello", "stream"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	should.Nil(iter.Error)
+	should.Equal("stream", iter.ReadString())
+}
+
+func Test_skip_null(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[null , "stream"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	if iter.ReadString() != "stream" {
+		t.FailNow()
+	}
+}
+
+func Test_skip_true(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[true , "stream"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	if iter.ReadString() != "stream" {
+		t.FailNow()
+	}
+}
+
+func Test_skip_false(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[false , "stream"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	if iter.ReadString() != "stream" {
+		t.FailNow()
+	}
+}
+
+func Test_skip_array(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[[1, [2, [3], 4]], "stream"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	if iter.ReadString() != "stream" {
+		t.FailNow()
+	}
+}
+
+func Test_skip_empty_array(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[ [ ], "stream"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	if iter.ReadString() != "stream" {
+		t.FailNow()
+	}
+}
+
+func Test_skip_nested(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[ {"a" : [{"stream": "c"}], "d": 102 }, "stream"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	if iter.ReadString() != "stream" {
+		t.FailNow()
+	}
+}
+
+func Test_skip_and_return_bytes(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[ {"a" : [{"stream": "c"}], "d": 102 }, "stream"]`)
+	iter.ReadArray()
+	skipped := iter.SkipAndReturnBytes()
+	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 := jsoniter.Parse(jsoniter.ConfigDefault, bytes.NewBufferString(`[ {"a" : [{"stream": "c"}], "d": 102 }, "stream"]`), 4)
+	iter.ReadArray()
+	skipped := iter.SkipAndReturnBytes()
+	should.Equal(`{"a" : [{"stream": "c"}], "d": 102 }`, string(skipped))
+}
+
+func Test_skip_empty(t *testing.T) {
+	should := require.New(t)
+	should.NotNil(jsoniter.Get([]byte("")).LastError())
+}
+
+type TestResp struct {
+	Code uint64
+}
+
+func Benchmark_jsoniter_skip(b *testing.B) {
+	input := []byte(`
+{
+    "_shards":{
+        "total" : 5,
+        "successful" : 5,
+        "failed" : 0
+    },
+    "hits":{
+        "total" : 1,
+        "hits" : [
+            {
+                "_index" : "twitter",
+                "_type" : "tweet",
+                "_id" : "1",
+                "_source" : {
+                    "user" : "kimchy",
+                    "postDate" : "2009-11-15T14:12:12",
+                    "message" : "trying out Elasticsearch"
+                }
+            }
+        ]
+    },
+    "code": 200
+}`)
+	for n := 0; n < b.N; n++ {
+		result := TestResp{}
+		iter := jsoniter.ParseBytes(jsoniter.ConfigDefault, input)
+		for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
+			switch field {
+			case "code":
+				result.Code = iter.ReadUint64()
+			default:
+				iter.Skip()
+			}
+		}
+	}
+}
+
+func Benchmark_json_skip(b *testing.B) {
+	input := []byte(`
+{
+    "_shards":{
+        "total" : 5,
+        "successful" : 5,
+        "failed" : 0
+    },
+    "hits":{
+        "total" : 1,
+        "hits" : [
+            {
+                "_index" : "twitter",
+                "_type" : "tweet",
+                "_id" : "1",
+                "_source" : {
+                    "user" : "kimchy",
+                    "postDate" : "2009-11-15T14:12:12",
+                    "message" : "trying out Elasticsearch"
+                }
+            }
+        ]
+    },
+    "code": 200
+}`)
+	for n := 0; n < b.N; n++ {
+		result := TestResp{}
+		json.Unmarshal(input, &result)
+	}
+}

vendor/github.com/json-iterator/go/skip_tests/skip_test.go

@@ -0,0 +1,45 @@
+package skip_tests
+
+import (
+	"encoding/json"
+	"errors"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"io"
+	"reflect"
+	"testing"
+)
+
+type testCase struct {
+	ptr    interface{}
+	inputs []string
+}
+
+var testCases []testCase
+
+func Test_skip(t *testing.T) {
+	for _, testCase := range testCases {
+		valType := reflect.TypeOf(testCase.ptr).Elem()
+		for _, input := range testCase.inputs {
+			t.Run(input, func(t *testing.T) {
+				should := require.New(t)
+				ptrVal := reflect.New(valType)
+				stdErr := json.Unmarshal([]byte(input), ptrVal.Interface())
+				iter := jsoniter.ParseString(jsoniter.ConfigDefault, input)
+				iter.Skip()
+				iter.ReadNil() // trigger looking forward
+				err := iter.Error
+				if err == io.EOF {
+					err = nil
+				} else {
+					err = errors.New("remaining bytes")
+				}
+				if stdErr == nil {
+					should.Nil(err)
+				} else {
+					should.NotNil(err)
+				}
+			})
+		}
+	}
+}

vendor/github.com/json-iterator/go/skip_tests/string_test.go

@@ -0,0 +1,17 @@
+package skip_tests
+
+func init() {
+	testCases = append(testCases, testCase{
+		ptr: (*string)(nil),
+		inputs: []string{
+			`""`,       // valid
+			`"hello"`,  // valid
+			`"`,        // invalid
+			`"\"`,      // invalid
+			`"\x00"`,   // invalid
+			"\"\x00\"", // invalid
+			"\"\t\"",   // invalid
+			`"\t"`,     // valid
+		},
+	})
+}

vendor/github.com/json-iterator/go/skip_tests/struct_test.go

@@ -0,0 +1,19 @@
+package skip_tests
+
+func init() {
+	testCases = append(testCases, testCase{
+		ptr: (*struct{})(nil),
+		inputs: []string{
+			`{}`,                         // valid
+			`{"hello":"world"}`,          // valid
+			`{hello:"world"}`,            // invalid
+			`{"hello:"world"}`,           // invalid
+			`{"hello","world"}`,          // invalid
+			`{"hello":{}`,                // invalid
+			`{"hello":{}}`,               // valid
+			`{"hello":{}}}`,              // invalid
+			`{"hello":  {  "hello": 1}}`, // valid
+			`{abc}`, // invalid
+		},
+	})
+}