Update vendor/github.com/envoyproxy/go-control-plane to 0.12.0

16 files changed, 9 insertions, 4579 deletions

diff --git a/vendor/google.golang.org/protobuf/internal/encoding/defval/default_test.go b/vendor/google.golang.org/protobuf/internal/encoding/defval/default_test.go
deleted file mode 100644
index bde8ca2aa3..0000000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/defval/default_test.go
+++ /dev/null
@@ -1,105 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package defval_test
-
-import (
-	"math"
-	"reflect"
-	"testing"
-
-	"google.golang.org/protobuf/internal/encoding/defval"
-	"google.golang.org/protobuf/internal/filedesc"
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-func Test(t *testing.T) {
-	evs := filedesc.EnumValues{List: []filedesc.EnumValue{{}}}
-	evs.List[0].L0.ParentFile = filedesc.SurrogateProto2
-	evs.List[0].L0.FullName = "ALPHA"
-	evs.List[0].L1.Number = 1
-
-	V := protoreflect.ValueOf
-	tests := []struct {
-		val   protoreflect.Value
-		enum  protoreflect.EnumValueDescriptor
-		enums protoreflect.EnumValueDescriptors
-		kind  protoreflect.Kind
-		strPB string
-		strGo string
-	}{{
-		val:   V(bool(true)),
-		enum:  nil,
-		enums: nil,
-		kind:  protoreflect.BoolKind,
-		strPB: "true",
-		strGo: "1",
-	}, {
-		val:   V(int32(-0x1234)),
-		enum:  nil,
-		enums: nil,
-		kind:  protoreflect.Int32Kind,
-		strPB: "-4660",
-		strGo: "-4660",
-	}, {
-		val:   V(float32(math.Pi)),
-		enum:  nil,
-		enums: nil,
-		kind:  protoreflect.FloatKind,
-		strPB: "3.1415927",
-		strGo: "3.1415927",
-	}, {
-		val:   V(float64(math.Pi)),
-		enum:  nil,
-		enums: nil,
-		kind:  protoreflect.DoubleKind,
-		strPB: "3.141592653589793",
-		strGo: "3.141592653589793",
-	}, {
-		val:   V(string("hello, \xde\xad\xbe\xef\n")),
-		enum:  nil,
-		enums: nil,
-		kind:  protoreflect.StringKind,
-		strPB: "hello, \xde\xad\xbe\xef\n",
-		strGo: "hello, \xde\xad\xbe\xef\n",
-	}, {
-		val:   V([]byte("hello, \xde\xad\xbe\xef\n")),
-		enum:  nil,
-		enums: nil,
-		kind:  protoreflect.BytesKind,
-		strPB: "hello, \\336\\255\\276\\357\\n",
-		strGo: "hello, \\336\\255\\276\\357\\n",
-	}, {
-		val:   V(protoreflect.EnumNumber(1)),
-		enum:  &evs.List[0],
-		enums: &evs,
-		kind:  protoreflect.EnumKind,
-		strPB: "ALPHA",
-		strGo: "1",
-	}}
-
-	for _, tt := range tests {
-		t.Run("", func(t *testing.T) {
-			gotStr, _ := defval.Marshal(tt.val, tt.enum, tt.kind, defval.Descriptor)
-			if gotStr != tt.strPB {
-				t.Errorf("Marshal(%v, %v, Descriptor) = %q, want %q", tt.val, tt.kind, gotStr, tt.strPB)
-			}
-
-			gotStr, _ = defval.Marshal(tt.val, tt.enum, tt.kind, defval.GoTag)
-			if gotStr != tt.strGo {
-				t.Errorf("Marshal(%v, %v, GoTag) = %q, want %q", tt.val, tt.kind, gotStr, tt.strGo)
-			}
-
-			gotVal, gotEnum, _ := defval.Unmarshal(tt.strPB, tt.kind, tt.enums, defval.Descriptor)
-			if !reflect.DeepEqual(gotVal.Interface(), tt.val.Interface()) || gotEnum != tt.enum {
-				t.Errorf("Unmarshal(%v, %v, Descriptor) = (%q, %v), want (%q, %v)", tt.strPB, tt.kind, gotVal, gotEnum, tt.val, tt.enum)
-			}
-
-			gotVal, gotEnum, _ = defval.Unmarshal(tt.strGo, tt.kind, tt.enums, defval.GoTag)
-			if !reflect.DeepEqual(gotVal.Interface(), tt.val.Interface()) || gotEnum != tt.enum {
-				t.Errorf("Unmarshal(%v, %v, GoTag) = (%q, %v), want (%q, %v)", tt.strGo, tt.kind, gotVal, gotEnum, tt.val, tt.enum)
-			}
-		})
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/defval/gotest/ya.make b/vendor/google.golang.org/protobuf/internal/encoding/defval/gotest/ya.make
deleted file mode 100644
index 90edb812b1..0000000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/defval/gotest/ya.make
+++ /dev/null
@@ -1,5 +0,0 @@
-GO_TEST_FOR(vendor/google.golang.org/protobuf/internal/encoding/defval)
-
-LICENSE(BSD-3-Clause)
-
-END()
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/defval/ya.make b/vendor/google.golang.org/protobuf/internal/encoding/defval/ya.make
index 96b84b177e..9f5b5a3fb7 100644
--- a/vendor/google.golang.org/protobuf/internal/encoding/defval/ya.make
+++ b/vendor/google.golang.org/protobuf/internal/encoding/defval/ya.make
@@ -2,10 +2,8 @@ GO_LIBRARY()
 
 LICENSE(BSD-3-Clause)
 
-SRCS(default.go)
-
-GO_XTEST_SRCS(default_test.go)
+SRCS(
+    default.go
+)
 
 END()
-
-RECURSE(gotest)
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/bench_test.go b/vendor/google.golang.org/protobuf/internal/encoding/json/bench_test.go
deleted file mode 100644
index 284b141a8e..0000000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/json/bench_test.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package json_test
-
-import (
-	"testing"
-
-	"google.golang.org/protobuf/internal/encoding/json"
-)
-
-func BenchmarkFloat(b *testing.B) {
-	input := []byte(`1.797693134862315708145274237317043567981e+308`)
-	for i := 0; i < b.N; i++ {
-		dec := json.NewDecoder(input)
-		val, err := dec.Read()
-		if err != nil {
-			b.Fatal(err)
-		}
-		if _, ok := val.Float(64); !ok {
-			b.Fatal("not a float")
-		}
-	}
-}
-
-func BenchmarkInt(b *testing.B) {
-	input := []byte(`922337203.6854775807e+10`)
-	for i := 0; i < b.N; i++ {
-		dec := json.NewDecoder(input)
-		val, err := dec.Read()
-		if err != nil {
-			b.Fatal(err)
-		}
-		if _, ok := val.Int(64); !ok {
-			b.Fatal("not an int64")
-		}
-	}
-}
-
-func BenchmarkString(b *testing.B) {
-	input := []byte(`"abcdefghijklmnopqrstuvwxyz0123456789\\n\\t"`)
-	for i := 0; i < b.N; i++ {
-		dec := json.NewDecoder(input)
-		val, err := dec.Read()
-		if err != nil {
-			b.Fatal(err)
-		}
-		_ = val.ParsedString()
-	}
-}
-
-func BenchmarkBool(b *testing.B) {
-	input := []byte(`true`)
-	for i := 0; i < b.N; i++ {
-		dec := json.NewDecoder(input)
-		val, err := dec.Read()
-		if err != nil {
-			b.Fatal(err)
-		}
-		_ = val.Bool()
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/decode_test.go b/vendor/google.golang.org/protobuf/internal/encoding/json/decode_test.go
deleted file mode 100644
index d70c3de0e0..0000000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/json/decode_test.go
+++ /dev/null
@@ -1,1414 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package json_test
-
-import (
-	"fmt"
-	"math"
-	"strings"
-	"testing"
-	"unicode/utf8"
-
-	"github.com/google/go-cmp/cmp"
-
-	"google.golang.org/protobuf/internal/encoding/json"
-)
-
-type R struct {
-	// E is expected error substring from calling Decoder.Read if set.
-	E string
-	// V is one of the checker implementations that validates the token value.
-	V checker
-	// P is expected Token.Pos() if set > 0.
-	P int
-	// RS is expected result from Token.RawString() if not empty.
-	RS string
-}
-
-// checker defines API for Token validation.
-type checker interface {
-	// check checks and expects for token API call to return and compare
-	// against implementation-stored value. Returns empty string if success,
-	// else returns error message describing the error.
-	check(json.Token) string
-}
-
-// checkers that checks the token kind only.
-var (
-	EOF         = kindOnly{json.EOF}
-	Null        = kindOnly{json.Null}
-	ObjectOpen  = kindOnly{json.ObjectOpen}
-	ObjectClose = kindOnly{json.ObjectClose}
-	ArrayOpen   = kindOnly{json.ArrayOpen}
-	ArrayClose  = kindOnly{json.ArrayClose}
-)
-
-type kindOnly struct {
-	want json.Kind
-}
-
-func (x kindOnly) check(tok json.Token) string {
-	if got := tok.Kind(); got != x.want {
-		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, x.want)
-	}
-	return ""
-}
-
-type Name struct {
-	val string
-}
-
-func (x Name) check(tok json.Token) string {
-	if got := tok.Kind(); got != json.Name {
-		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Name)
-	}
-
-	if got := tok.Name(); got != x.val {
-		return fmt.Sprintf("Token.Name(): got %v, want %v", got, x.val)
-	}
-	return ""
-}
-
-type Bool struct {
-	val bool
-}
-
-func (x Bool) check(tok json.Token) string {
-	if got := tok.Kind(); got != json.Bool {
-		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Bool)
-	}
-
-	if got := tok.Bool(); got != x.val {
-		return fmt.Sprintf("Token.Bool(): got %v, want %v", got, x.val)
-	}
-	return ""
-}
-
-type Str struct {
-	val string
-}
-
-func (x Str) check(tok json.Token) string {
-	if got := tok.Kind(); got != json.String {
-		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.String)
-	}
-
-	if got := tok.ParsedString(); got != x.val {
-		return fmt.Sprintf("Token.ParsedString(): got %v, want %v", got, x.val)
-	}
-	return ""
-}
-
-type F64 struct {
-	val float64
-}
-
-func (x F64) check(tok json.Token) string {
-	if got := tok.Kind(); got != json.Number {
-		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
-	}
-
-	got, ok := tok.Float(64)
-	if !ok {
-		return fmt.Sprintf("Token.Float(64): returned not ok")
-	}
-	if got != x.val {
-		return fmt.Sprintf("Token.Float(64): got %v, want %v", got, x.val)
-	}
-	return ""
-}
-
-type F32 struct {
-	val float32
-}
-
-func (x F32) check(tok json.Token) string {
-	if got := tok.Kind(); got != json.Number {
-		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
-	}
-
-	got, ok := tok.Float(32)
-	if !ok {
-		return fmt.Sprintf("Token.Float(32): returned not ok")
-	}
-	if float32(got) != x.val {
-		return fmt.Sprintf("Token.Float(32): got %v, want %v", got, x.val)
-	}
-	return ""
-}
-
-// NotF64 is a checker to validate a Number token where Token.Float(64) returns not ok.
-var NotF64 = xf64{}
-
-type xf64 struct{}
-
-func (x xf64) check(tok json.Token) string {
-	if got := tok.Kind(); got != json.Number {
-		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
-	}
-
-	_, ok := tok.Float(64)
-	if ok {
-		return fmt.Sprintf("Token.Float(64): returned ok")
-	}
-	return ""
-}
-
-// NotF32 is a checker to validate a Number token where Token.Float(32) returns not ok.
-var NotF32 = xf32{}
-
-type xf32 struct{}
-
-func (x xf32) check(tok json.Token) string {
-	if got := tok.Kind(); got != json.Number {
-		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
-	}
-
-	_, ok := tok.Float(32)
-	if ok {
-		return fmt.Sprintf("Token.Float(32): returned ok")
-	}
-	return ""
-}
-
-type I64 struct {
-	val int64
-}
-
-func (x I64) check(tok json.Token) string {
-	if got := tok.Kind(); got != json.Number {
-		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
-	}
-
-	got, ok := tok.Int(64)
-	if !ok {
-		return fmt.Sprintf("Token.Int(64): returned not ok")
-	}
-	if got != x.val {
-		return fmt.Sprintf("Token.Int(64): got %v, want %v", got, x.val)
-	}
-	return ""
-}
-
-type I32 struct {
-	val int32
-}
-
-func (x I32) check(tok json.Token) string {
-	if got := tok.Kind(); got != json.Number {
-		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
-	}
-
-	got, ok := tok.Int(32)
-	if !ok {
-		return fmt.Sprintf("Token.Int(32): returned not ok")
-	}
-	if int32(got) != x.val {
-		return fmt.Sprintf("Token.Int(32): got %v, want %v", got, x.val)
-	}
-	return ""
-}
-
-// NotI64 is a checker to validate a Number token where Token.Int(64) returns not ok.
-var NotI64 = xi64{}
-
-type xi64 struct{}
-
-func (x xi64) check(tok json.Token) string {
-	if got := tok.Kind(); got != json.Number {
-		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
-	}
-
-	_, ok := tok.Int(64)
-	if ok {
-		return fmt.Sprintf("Token.Int(64): returned ok")
-	}
-	return ""
-}
-
-// NotI32 is a checker to validate a Number token where Token.Int(32) returns not ok.
-var NotI32 = xi32{}
-
-type xi32 struct{}
-
-func (x xi32) check(tok json.Token) string {
-	if got := tok.Kind(); got != json.Number {
-		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
-	}
-
-	_, ok := tok.Int(32)
-	if ok {
-		return fmt.Sprintf("Token.Int(32): returned ok")
-	}
-	return ""
-}
-
-type Ui64 struct {
-	val uint64
-}
-
-func (x Ui64) check(tok json.Token) string {
-	if got := tok.Kind(); got != json.Number {
-		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
-	}
-
-	got, ok := tok.Uint(64)
-	if !ok {
-		return fmt.Sprintf("Token.Uint(64): returned not ok")
-	}
-	if got != x.val {
-		return fmt.Sprintf("Token.Uint(64): got %v, want %v", got, x.val)
-	}
-	return ""
-}
-
-type Ui32 struct {
-	val uint32
-}
-
-func (x Ui32) check(tok json.Token) string {
-	if got := tok.Kind(); got != json.Number {
-		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
-	}
-
-	got, ok := tok.Uint(32)
-	if !ok {
-		return fmt.Sprintf("Token.Uint(32): returned not ok")
-	}
-	if uint32(got) != x.val {
-		return fmt.Sprintf("Token.Uint(32): got %v, want %v", got, x.val)
-	}
-	return ""
-}
-
-// NotUi64 is a checker to validate a Number token where Token.Uint(64) returns not ok.
-var NotUi64 = xui64{}
-
-type xui64 struct{}
-
-func (x xui64) check(tok json.Token) string {
-	if got := tok.Kind(); got != json.Number {
-		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
-	}
-
-	_, ok := tok.Uint(64)
-	if ok {
-		return fmt.Sprintf("Token.Uint(64): returned ok")
-	}
-	return ""
-}
-
-// NotI32 is a checker to validate a Number token where Token.Uint(32) returns not ok.
-var NotUi32 = xui32{}
-
-type xui32 struct{}
-
-func (x xui32) check(tok json.Token) string {
-	if got := tok.Kind(); got != json.Number {
-		return fmt.Sprintf("Token.Kind(): got %v, want %v", got, json.Number)
-	}
-
-	_, ok := tok.Uint(32)
-	if ok {
-		return fmt.Sprintf("Token.Uint(32): returned ok")
-	}
-	return ""
-}
-
-var errEOF = json.ErrUnexpectedEOF.Error()
-
-func TestDecoder(t *testing.T) {
-	const space = " \n\r\t"
-
-	tests := []struct {
-		in string
-		// want is a list of expected values returned from calling
-		// Decoder.Read. An item makes the test code invoke
-		// Decoder.Read and compare against R.E for error returned or use R.V to
-		// validate the returned Token object.
-		want []R
-	}{
-		{
-			in:   ``,
-			want: []R{{V: EOF}},
-		},
-		{
-			in:   space,
-			want: []R{{V: EOF}},
-		},
-		{
-			// Calling Read after EOF will keep returning EOF for
-			// succeeding Read calls.
-			in: space,
-			want: []R{
-				{V: EOF},
-				{V: EOF},
-				{V: EOF},
-			},
-		},
-
-		// JSON literals.
-		{
-			in: space + `null` + space,
-			want: []R{
-				{V: Null, P: len(space), RS: `null`},
-				{V: EOF},
-			},
-		},
-		{
-			in: space + `true` + space,
-			want: []R{
-				{V: Bool{true}},
-				{V: EOF},
-			},
-		},
-		{
-			in: space + `false` + space,
-			want: []R{
-				{V: Bool{false}},
-				{V: EOF},
-			},
-		},
-		{
-			// Error returned will produce the same error again.
-			in: space + `foo` + space,
-			want: []R{
-				{E: `invalid value foo`},
-				{E: `invalid value foo`},
-			},
-		},
-
-		// JSON strings.
-		{
-			in: space + `""` + space,
-			want: []R{
-				{V: Str{}},
-				{V: EOF},
-			},
-		},
-		{
-			in: space + `"hello"` + space,
-			want: []R{
-				{V: Str{"hello"}, RS: `"hello"`},
-				{V: EOF},
-			},
-		},
-		{
-			in:   `"hello`,
-			want: []R{{E: errEOF}},
-		},
-		{
-			in:   "\"\x00\"",
-			want: []R{{E: `invalid character '\x00' in string`}},
-		},
-		{
-			in: "\"\u0031\u0032\"",
-			want: []R{
-				{V: Str{"12"}, RS: "\"\u0031\u0032\""},
-				{V: EOF},
-			},
-		},
-		{
-			// Invalid UTF-8 error is returned in ReadString instead of Read.
-			in:   "\"\xff\"",
-			want: []R{{E: `syntax error (line 1:1): invalid UTF-8 in string`}},
-		},
-		{
-			in: `"` + string(utf8.RuneError) + `"`,
-			want: []R{
-				{V: Str{string(utf8.RuneError)}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `"\uFFFD"`,
-			want: []R{
-				{V: Str{string(utf8.RuneError)}},
-				{V: EOF},
-			},
-		},
-		{
-			in:   `"\x"`,
-			want: []R{{E: `invalid escape code "\\x" in string`}},
-		},
-		{
-			in:   `"\uXXXX"`,
-			want: []R{{E: `invalid escape code "\\uXXXX" in string`}},
-		},
-		{
-			in:   `"\uDEAD"`, // unmatched surrogate pair
-			want: []R{{E: errEOF}},
-		},
-		{
-			in:   `"\uDEAD\uBEEF"`, // invalid surrogate half
-			want: []R{{E: `invalid escape code "\\uBEEF" in string`}},
-		},
-		{
-			in: `"\uD800\udead"`, // valid surrogate pair
-			want: []R{
-				{V: Str{`𐊭`}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `"\u0000\"\\\/\b\f\n\r\t"`,
-			want: []R{
-				{V: Str{"\u0000\"\\/\b\f\n\r\t"}},
-				{V: EOF},
-			},
-		},
-
-		// Invalid JSON numbers.
-		{
-			in:   `-`,
-			want: []R{{E: `invalid value -`}},
-		},
-		{
-			in:   `+0`,
-			want: []R{{E: `invalid value +0`}},
-		},
-		{
-			in:   `-+`,
-			want: []R{{E: `invalid value -+`}},
-		},
-		{
-			in:   `0.`,
-			want: []R{{E: `invalid value 0.`}},
-		},
-		{
-			in:   `.1`,
-			want: []R{{E: `invalid value .1`}},
-		},
-		{
-			in:   `1.0.1`,
-			want: []R{{E: `invalid value 1.0.1`}},
-		},
-		{
-			in:   `1..1`,
-			want: []R{{E: `invalid value 1..1`}},
-		},
-		{
-			in:   `-1-2`,
-			want: []R{{E: `invalid value -1-2`}},
-		},
-		{
-			in:   `01`,
-			want: []R{{E: `invalid value 01`}},
-		},
-		{
-			in:   `1e`,
-			want: []R{{E: `invalid value 1e`}},
-		},
-		{
-			in:   `1e1.2`,
-			want: []R{{E: `invalid value 1e1.2`}},
-		},
-		{
-			in:   `1Ee`,
-			want: []R{{E: `invalid value 1Ee`}},
-		},
-		{
-			in:   `1.e1`,
-			want: []R{{E: `invalid value 1.e1`}},
-		},
-		{
-			in:   `1.e+`,
-			want: []R{{E: `invalid value 1.e+`}},
-		},
-		{
-			in:   `1e+-2`,
-			want: []R{{E: `invalid value 1e+-2`}},
-		},
-		{
-			in:   `1e--2`,
-			want: []R{{E: `invalid value 1e--2`}},
-		},
-		{
-			in:   `1.0true`,
-			want: []R{{E: `invalid value 1.0true`}},
-		},
-
-		// JSON numbers as floating point.
-		{
-			in: space + `0.0` + space,
-			want: []R{
-				{V: F32{0}, P: len(space), RS: `0.0`},
-				{V: EOF},
-			},
-		},
-		{
-			in: space + `0` + space,
-			want: []R{
-				{V: F32{0}},
-				{V: EOF},
-			},
-		},
-		{
-			in: space + `-0` + space,
-			want: []R{
-				{V: F32{float32(math.Copysign(0, -1))}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `-0`,
-			want: []R{
-				{V: F64{math.Copysign(0, -1)}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `-0.0`,
-			want: []R{
-				{V: F32{float32(math.Copysign(0, -1))}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `-0.0`,
-			want: []R{
-				{V: F64{math.Copysign(0, -1)}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `-1.02`,
-			want: []R{
-				{V: F32{-1.02}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `1.020000`,
-			want: []R{
-				{V: F32{1.02}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `-1.0e0`,
-			want: []R{
-				{V: F32{-1}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `1.0e-000`,
-			want: []R{
-				{V: F32{1}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `1e+00`,
-			want: []R{
-				{V: F32{1}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `1.02e3`,
-			want: []R{
-				{V: F32{1.02e3}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `-1.02E03`,
-			want: []R{
-				{V: F32{-1.02e3}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `1.0200e+3`,
-			want: []R{
-				{V: F32{1.02e3}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `-1.0200E+03`,
-			want: []R{
-				{V: F32{-1.02e3}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `1.0200e-3`,
-			want: []R{
-				{V: F32{1.02e-3}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `-1.0200E-03`,
-			want: []R{
-				{V: F32{-1.02e-3}},
-				{V: EOF},
-			},
-		},
-		{
-			// Exceeds max float32 limit, but should be ok for float64.
-			in: `3.4e39`,
-			want: []R{
-				{V: F64{3.4e39}},
-				{V: EOF},
-			},
-		},
-
-		{
-			// Exceeds max float32 limit.
-			in: `3.4e39`,
-			want: []R{
-				{V: NotF32},
-				{V: EOF},
-			},
-		},
-		{
-			// Less than negative max float32 limit.
-			in: `-3.4e39`,
-			want: []R{
-				{V: NotF32},
-				{V: EOF},
-			},
-		},
-		{
-			// Exceeds max float64 limit.
-			in: `1.79e+309`,
-			want: []R{
-				{V: NotF64},
-				{V: EOF},
-			},
-		},
-		{
-			// Less than negative max float64 limit.
-			in: `-1.79e+309`,
-			want: []R{
-				{V: NotF64},
-				{V: EOF},
-			},
-		},
-
-		// JSON numbers as signed integers.
-		{
-			in: space + `0` + space,
-			want: []R{
-				{V: I32{0}},
-				{V: EOF},
-			},
-		},
-		{
-			in: space + `-0` + space,
-			want: []R{
-				{V: I32{0}},
-				{V: EOF},
-			},
-		},
-		{
-			// Fractional part equals 0 is ok.
-			in: `1.00000`,
-			want: []R{
-				{V: I32{1}},
-				{V: EOF},
-			},
-		},
-		{
-			// Fractional part not equals 0 returns error.
-			in: `1.0000000001`,
-			want: []R{
-				{V: NotI32},
-				{V: EOF},
-			},
-		},
-		{
-			in: `0e0`,
-			want: []R{
-				{V: I32{0}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `0.0E0`,
-			want: []R{
-				{V: I32{0}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `0.0E10`,
-			want: []R{
-				{V: I32{0}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `-1`,
-			want: []R{
-				{V: I32{-1}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `1.0e+0`,
-			want: []R{
-				{V: I32{1}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `-1E-0`,
-			want: []R{
-				{V: I32{-1}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `1E1`,
-			want: []R{
-				{V: I32{10}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `-100.00e-02`,
-			want: []R{
-				{V: I32{-1}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `0.1200E+02`,
-			want: []R{
-				{V: I64{12}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `0.012e2`,
-			want: []R{
-				{V: NotI32},
-				{V: EOF},
-			},
-		},
-		{
-			in: `12e-2`,
-			want: []R{
-				{V: NotI32},
-				{V: EOF},
-			},
-		},
-		{
-			// Exceeds math.MaxInt32.
-			in: `2147483648`,
-			want: []R{
-				{V: NotI32},
-				{V: EOF},
-			},
-		},
-		{
-			// Exceeds math.MinInt32.
-			in: `-2147483649`,
-			want: []R{
-				{V: NotI32},
-				{V: EOF},
-			},
-		},
-		{
-			// Exceeds math.MaxInt32, but ok for int64.
-			in: `2147483648`,
-			want: []R{
-				{V: I64{2147483648}},
-				{V: EOF},
-			},
-		},
-		{
-			// Exceeds math.MinInt32, but ok for int64.
-			in: `-2147483649`,
-			want: []R{
-				{V: I64{-2147483649}},
-				{V: EOF},
-			},
-		},
-		{
-			// Exceeds math.MaxInt64.
-			in: `9223372036854775808`,
-			want: []R{
-				{V: NotI64},
-				{V: EOF},
-			},
-		},
-		{
-			// Exceeds math.MinInt64.
-			in: `-9223372036854775809`,
-			want: []R{
-				{V: NotI64},
-				{V: EOF},
-			},
-		},
-
-		// JSON numbers as unsigned integers.
-		{
-			in: space + `0` + space,
-			want: []R{
-				{V: Ui32{0}},
-				{V: EOF},
-			},
-		},
-		{
-			in: space + `-0` + space,
-			want: []R{
-				{V: Ui32{0}},
-				{V: EOF},
-			},
-		},
-		{
-			in: `-1`,
-			want: []R{
-				{V: NotUi32},
-				{V: EOF},
-			},
-		},
-		{
-			// Exceeds math.MaxUint32.
-			in: `4294967296`,
-			want: []R{
-				{V: NotUi32},
-				{V: EOF},
-			},
-		},
-		{
-			// Exceeds math.MaxUint64.
-			in: `18446744073709551616`,
-			want: []R{
-				{V: NotUi64},
-				{V: EOF},
-			},
-		},
-
-		// JSON sequence of values.
-		{
-			in: `true null`,
-			want: []R{
-				{V: Bool{true}},
-				{E: `(line 1:6): unexpected token null`},
-			},
-		},
-		{
-			in: "null false",
-			want: []R{
-				{V: Null},
-				{E: `unexpected token false`},
-			},
-		},
-		{
-			in: `true,false`,
-			want: []R{
-				{V: Bool{true}},
-				{E: `unexpected token ,`},
-			},
-		},
-		{
-			in: `47"hello"`,
-			want: []R{
-				{V: I32{47}},
-				{E: `unexpected token "hello"`},
-			},
-		},
-		{
-			in: `47 "hello"`,
-			want: []R{
-				{V: I32{47}},
-				{E: `unexpected token "hello"`},
-			},
-		},
-		{
-			in: `true 42`,
-			want: []R{
-				{V: Bool{true}},
-				{E: `unexpected token 42`},
-			},
-		},
-
-		// JSON arrays.
-		{
-			in: space + `[]` + space,
-			want: []R{
-				{V: ArrayOpen},
-				{V: ArrayClose},
-				{V: EOF},
-			},
-		},
-		{
-			in: space + `[` + space + `]` + space,
-			want: []R{
-				{V: ArrayOpen, P: len(space), RS: `[`},
-				{V: ArrayClose},
-				{V: EOF},
-			},
-		},
-		{
-			in: space + `[` + space,
-			want: []R{
-				{V: ArrayOpen},
-				{E: errEOF},
-			},
-		},
-		{
-			in:   space + `]` + space,
-			want: []R{{E: `unexpected token ]`}},
-		},
-		{
-			in: `[null,true,false,  1e1, "hello"   ]`,
-			want: []R{
-				{V: ArrayOpen},
-				{V: Null},
-				{V: Bool{true}},
-				{V: Bool{false}},
-				{V: I32{10}},
-				{V: Str{"hello"}},
-				{V: ArrayClose},
-				{V: EOF},
-			},
-		},
-		{
-			in: `[` + space + `true` + space + `,` + space + `"hello"` + space + `]`,
-			want: []R{
-				{V: ArrayOpen},
-				{V: Bool{true}},
-				{V: Str{"hello"}},
-				{V: ArrayClose},
-				{V: EOF},
-			},
-		},
-		{
-			in: `[` + space + `true` + space + `,` + space + `]`,
-			want: []R{
-				{V: ArrayOpen},
-				{V: Bool{true}},
-				{E: `unexpected token ]`},
-			},
-		},
-		{
-			in: `[` + space + `false` + space + `]`,
-			want: []R{
-				{V: ArrayOpen},
-				{V: Bool{false}},
-				{V: ArrayClose},
-				{V: EOF},
-			},
-		},
-		{
-			in: `[` + space + `1` + space + `0` + space + `]`,
-			want: []R{
-				{V: ArrayOpen},
-				{V: I64{1}},
-				{E: `unexpected token 0`},
-			},
-		},
-		{
-			in: `[null`,
-			want: []R{
-				{V: ArrayOpen},
-				{V: Null},
-				{E: errEOF},
-			},
-		},
-		{
-			in: `[foo]`,
-			want: []R{
-				{V: ArrayOpen},
-				{E: `invalid value foo`},
-			},
-		},
-		{
-			in: `[{}, "hello", [true, false], null]`,
-			want: []R{
-				{V: ArrayOpen},
-				{V: ObjectOpen},
-				{V: ObjectClose},
-				{V: Str{"hello"}},
-				{V: ArrayOpen},
-				{V: Bool{true}},
-				{V: Bool{false}},
-				{V: ArrayClose},
-				{V: Null},
-				{V: ArrayClose},
-				{V: EOF},
-			},
-		},
-		{
-			in: `[{ ]`,
-			want: []R{
-				{V: ArrayOpen},
-				{V: ObjectOpen},
-				{E: `unexpected token ]`},
-			},
-		},
-		{
-			in: `[[ ]`,
-			want: []R{
-				{V: ArrayOpen},
-				{V: ArrayOpen},
-				{V: ArrayClose},
-				{E: errEOF},
-			},
-		},
-		{
-			in: `[,]`,
-			want: []R{
-				{V: ArrayOpen},
-				{E: `unexpected token ,`},
-			},
-		},
-		{
-			in: `[true "hello"]`,
-			want: []R{
-				{V: ArrayOpen},
-				{V: Bool{true}},
-				{E: `unexpected token "hello"`},
-			},
-		},
-		{
-			in: `[] null`,
-			want: []R{
-				{V: ArrayOpen},
-				{V: ArrayClose},
-				{E: `unexpected token null`},
-			},
-		},
-		{
-			in: `true []`,
-			want: []R{
-				{V: Bool{true}},
-				{E: `unexpected token [`},
-			},
-		},
-
-		// JSON objects.
-		{
-			in: space + `{}` + space,
-			want: []R{
-				{V: ObjectOpen},
-				{V: ObjectClose},
-				{V: EOF},
-			},
-		},
-		{
-			in: space + `{` + space + `}` + space,
-			want: []R{
-				{V: ObjectOpen},
-				{V: ObjectClose},
-				{V: EOF},
-			},
-		},
-		{
-			in: space + `{` + space,
-			want: []R{
-				{V: ObjectOpen},
-				{E: errEOF},
-			},
-		},
-		{
-			in:   space + `}` + space,
-			want: []R{{E: `unexpected token }`}},
-		},
-		{
-			in: `{` + space + `null` + space + `}`,
-			want: []R{
-				{V: ObjectOpen},
-				{E: `unexpected token null`},
-			},
-		},
-		{
-			in: `{[]}`,
-			want: []R{
-				{V: ObjectOpen},
-				{E: `(line 1:2): unexpected token [`},
-			},
-		},
-		{
-			in: `{,}`,
-			want: []R{
-				{V: ObjectOpen},
-				{E: `unexpected token ,`},
-			},
-		},
-		{
-			in: `{"345678"}`,
-			want: []R{
-				{V: ObjectOpen},
-				{E: `(line 1:10): unexpected character }, missing ":" after field name`},
-			},
-		},
-		{
-			in: `{` + space + `"hello"` + space + `:` + space + `"world"` + space + `}`,
-			want: []R{
-				{V: ObjectOpen},
-				{V: Name{"hello"}, P: len(space) + 1, RS: `"hello"`},
-				{V: Str{"world"}, RS: `"world"`},
-				{V: ObjectClose},
-				{V: EOF},
-			},
-		},
-		{
-			in: `{"hello" "world"}`,
-			want: []R{
-				{V: ObjectOpen},
-				{E: `(line 1:10): unexpected character ", missing ":" after field name`},
-			},
-		},
-		{
-			in: `{"hello":`,
-			want: []R{
-				{V: ObjectOpen},
-				{V: Name{"hello"}},
-				{E: errEOF},
-			},
-		},
-		{
-			in: `{"hello":"world"`,
-			want: []R{
-				{V: ObjectOpen},
-				{V: Name{"hello"}},
-				{V: Str{"world"}},
-				{E: errEOF},
-			},
-		},
-		{
-			in: `{"hello":"world",`,
-			want: []R{
-				{V: ObjectOpen},
-				{V: Name{"hello"}},
-				{V: Str{"world"}},
-				{E: errEOF},
-			},
-		},
-		{
-			in: `{""`,
-			want: []R{
-				{V: ObjectOpen},
-				{E: errEOF},
-			},
-		},
-		{
-			in: `{"34":"89",}`,
-			want: []R{
-				{V: ObjectOpen},
-				{V: Name{"34"}, RS: `"34"`},
-				{V: Str{"89"}},
-				{E: `syntax error (line 1:12): unexpected token }`},
-			},
-		},
-		{
-			in: `{
-			  "number": 123e2,
-			  "bool"  : false,
-			  "object": {"string": "world"},
-			  "null"  : null,
-			  "array" : [1.01, "hello", true],
-			  "string": "hello"
-			}`,
-			want: []R{
-				{V: ObjectOpen},
-
-				{V: Name{"number"}},
-				{V: I32{12300}},
-
-				{V: Name{"bool"}},
-				{V: Bool{false}},
-
-				{V: Name{"object"}},
-				{V: ObjectOpen},
-				{V: Name{"string"}},
-				{V: Str{"world"}},
-				{V: ObjectClose},
-
-				{V: Name{"null"}},
-				{V: Null},
-
-				{V: Name{"array"}},
-				{V: ArrayOpen},
-				{V: F32{1.01}},
-				{V: Str{"hello"}},
-				{V: Bool{true}},
-				{V: ArrayClose},
-
-				{V: Name{"string"}},
-				{V: Str{"hello"}},
-
-				{V: ObjectClose},
-				{V: EOF},
-			},
-		},
-		{
-			in: `[
-			  {"object": {"number": 47}},
-			  ["list"],
-			  null
-			]`,
-			want: []R{
-				{V: ArrayOpen},
-
-				{V: ObjectOpen},
-				{V: Name{"object"}},
-				{V: ObjectOpen},
-				{V: Name{"number"}},
-				{V: I32{47}},
-				{V: ObjectClose},
-				{V: ObjectClose},
-
-				{V: ArrayOpen},
-				{V: Str{"list"}},
-				{V: ArrayClose},
-
-				{V: Null},
-
-				{V: ArrayClose},
-				{V: EOF},
-			},
-		},
-
-		// Tests for line and column info.
-		{
-			in: `12345678 x`,
-			want: []R{
-				{V: I64{12345678}},
-				{E: `syntax error (line 1:10): invalid value x`},
-			},
-		},
-		{
-			in: "\ntrue\n   x",
-			want: []R{
-				{V: Bool{true}},
-				{E: `syntax error (line 3:4): invalid value x`},
-			},
-		},
-		{
-			in: `"💩"x`,
-			want: []R{
-				{V: Str{"💩"}},
-				{E: `syntax error (line 1:4): invalid value x`},
-			},
-		},
-		{
-			in: "\n\n[\"🔥🔥🔥\"x",
-			want: []R{
-				{V: ArrayOpen},
-				{V: Str{"🔥🔥🔥"}},
-				{E: `syntax error (line 3:7): invalid value x`},
-			},
-		},
-		{
-			// Multi-rune emojis.
-			in: `["👍🏻👍🏿"x`,
-			want: []R{
-				{V: ArrayOpen},
-				{V: Str{"👍🏻👍🏿"}},
-				{E: `syntax error (line 1:8): invalid value x`},
-			},
-		},
-	}
-
-	for _, tc := range tests {
-		tc := tc
-		t.Run("", func(t *testing.T) {
-			dec := json.NewDecoder([]byte(tc.in))
-			for i, want := range tc.want {
-				peekTok, peekErr := dec.Peek()
-				tok, err := dec.Read()
-				if err != nil {
-					if want.E == "" {
-						errorf(t, tc.in, "want#%d: Read() got unexpected error: %v", i, err)
-					} else if !strings.Contains(err.Error(), want.E) {
-						errorf(t, tc.in, "want#%d: Read() got %q, want %q", i, err, want.E)
-					}
-					return
-				}
-				if want.E != "" {
-					errorf(t, tc.in, "want#%d: Read() got nil error, want %q", i, want.E)
-					return
-				}
-				checkToken(t, tok, i, want, tc.in)
-				if !cmp.Equal(tok, peekTok, cmp.Comparer(json.TokenEquals)) {
-					errorf(t, tc.in, "want#%d: Peek() %+v != Read() token %+v", i, peekTok, tok)
-				}
-				if err != peekErr {
-					errorf(t, tc.in, "want#%d: Peek() error %v != Read() error %v", i, err, peekErr)
-				}
-			}
-		})
-	}
-}
-
-func checkToken(t *testing.T, tok json.Token, idx int, r R, in string) {
-	// Validate Token.Pos() if R.P is set.
-	if r.P > 0 {
-		got := tok.Pos()
-		if got != r.P {
-			errorf(t, in, "want#%d: Token.Pos() got %v want %v", idx, got, r.P)
-		}
-	}
-	// Validate Token.RawString if R.RS is set.
-	if len(r.RS) > 0 {
-		got := tok.RawString()
-		if got != r.RS {
-			errorf(t, in, "want#%d: Token.RawString() got %v want %v", idx, got, r.P)
-		}
-	}
-
-	// Skip checking for Token details if r.V is not set.
-	if r.V == nil {
-		return
-	}
-
-	if err := r.V.check(tok); err != "" {
-		errorf(t, in, "want#%d: %s", idx, err)
-	}
-	return
-}
-
-func errorf(t *testing.T, in string, fmtStr string, args ...interface{}) {
-	t.Helper()
-	vargs := []interface{}{in}
-	for _, arg := range args {
-		vargs = append(vargs, arg)
-	}
-	t.Errorf("input:\n%s\n~end~\n"+fmtStr, vargs...)
-}
-
-func TestClone(t *testing.T) {
-	input := `{"outer":{"str":"hello", "number": 123}}`
-	dec := json.NewDecoder([]byte(input))
-
-	// Clone at the start should produce the same reads as the original.
-	clone := dec.Clone()
-	compareDecoders(t, dec, clone)
-
-	// Advance to inner object, clone and compare again.
-	dec.Read() // Read ObjectOpen.
-	dec.Read() // Read Name.
-	clone = dec.Clone()
-	compareDecoders(t, dec, clone)
-}
-
-func compareDecoders(t *testing.T, d1 *json.Decoder, d2 *json.Decoder) {
-	for {
-		tok1, err1 := d1.Read()
-		tok2, err2 := d2.Read()
-		if tok1.Kind() != tok2.Kind() {
-			t.Errorf("cloned decoder: got Kind %v, want %v", tok2.Kind(), tok1.Kind())
-		}
-		if tok1.RawString() != tok2.RawString() {
-			t.Errorf("cloned decoder: got RawString %v, want %v", tok2.RawString(), tok1.RawString())
-		}
-		if err1 != err2 {
-			t.Errorf("cloned decoder: got error %v, want %v", err2, err1)
-		}
-		if tok1.Kind() == json.EOF {
-			break
-		}
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/encode_test.go b/vendor/google.golang.org/protobuf/internal/encoding/json/encode_test.go
deleted file mode 100644
index c844b55319..0000000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/json/encode_test.go
+++ /dev/null
@@ -1,399 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package json_test
-
-import (
-	"math"
-	"strings"
-	"testing"
-
-	"github.com/google/go-cmp/cmp"
-	"github.com/google/go-cmp/cmp/cmpopts"
-
-	"google.golang.org/protobuf/internal/detrand"
-	"google.golang.org/protobuf/internal/encoding/json"
-)
-
-// Disable detrand to enable direct comparisons on outputs.
-func init() { detrand.Disable() }
-
-// splitLines is a cmpopts.Option for comparing strings with line breaks.
-var splitLines = cmpopts.AcyclicTransformer("SplitLines", func(s string) []string {
-	return strings.Split(s, "\n")
-})
-
-func TestEncoder(t *testing.T) {
-	tests := []struct {
-		desc          string
-		write         func(*json.Encoder)
-		wantOut       string
-		wantOutIndent string
-	}{
-		{
-			desc: "null",
-			write: func(e *json.Encoder) {
-				e.WriteNull()
-			},
-			wantOut: `null`,
-		},
-		{
-			desc: "true",
-			write: func(e *json.Encoder) {
-				e.WriteBool(true)
-			},
-			wantOut: `true`,
-		},
-		{
-			desc: "false",
-			write: func(e *json.Encoder) {
-				e.WriteBool(false)
-			},
-			wantOut: `false`,
-		},
-		{
-			desc: "string",
-			write: func(e *json.Encoder) {
-				e.WriteString("hello world")
-			},
-			wantOut: `"hello world"`,
-		},
-		{
-			desc: "string contains escaped characters",
-			write: func(e *json.Encoder) {
-				e.WriteString("\u0000\"\\/\b\f\n\r\t")
-			},
-			wantOut: `"\u0000\"\\/\b\f\n\r\t"`,
-		},
-		{
-			desc: "float64",
-			write: func(e *json.Encoder) {
-				e.WriteFloat(1.0199999809265137, 64)
-			},
-			wantOut: `1.0199999809265137`,
-		},
-		{
-			desc: "float64 max value",
-			write: func(e *json.Encoder) {
-				e.WriteFloat(math.MaxFloat64, 64)
-			},
-			wantOut: `1.7976931348623157e+308`,
-		},
-		{
-			desc: "float64 min value",
-			write: func(e *json.Encoder) {
-				e.WriteFloat(-math.MaxFloat64, 64)
-			},
-			wantOut: `-1.7976931348623157e+308`,
-		},
-		{
-			desc: "float64 NaN",
-			write: func(e *json.Encoder) {
-				e.WriteFloat(math.NaN(), 64)
-			},
-			wantOut: `"NaN"`,
-		},
-		{
-			desc: "float64 Infinity",
-			write: func(e *json.Encoder) {
-				e.WriteFloat(math.Inf(+1), 64)
-			},
-			wantOut: `"Infinity"`,
-		},
-		{
-			desc: "float64 -Infinity",
-			write: func(e *json.Encoder) {
-				e.WriteFloat(math.Inf(-1), 64)
-			},
-			wantOut: `"-Infinity"`,
-		},
-		{
-			desc: "float64 negative zero",
-			write: func(e *json.Encoder) {
-				e.WriteFloat(math.Copysign(0, -1), 64)
-			},
-			wantOut: `-0`,
-		},
-		{
-			desc: "float32",
-			write: func(e *json.Encoder) {
-				e.WriteFloat(1.02, 32)
-			},
-			wantOut: `1.02`,
-		},
-		{
-			desc: "float32 max value",
-			write: func(e *json.Encoder) {
-				e.WriteFloat(math.MaxFloat32, 32)
-			},
-			wantOut: `3.4028235e+38`,
-		},
-		{
-			desc: "float32 min value",
-			write: func(e *json.Encoder) {
-				e.WriteFloat(-math.MaxFloat32, 32)
-			},
-			wantOut: `-3.4028235e+38`,
-		},
-		{
-			desc: "float32 negative zero",
-			write: func(e *json.Encoder) {
-				e.WriteFloat(math.Copysign(0, -1), 32)
-			},
-			wantOut: `-0`,
-		},
-		{
-			desc: "int",
-			write: func(e *json.Encoder) {
-				e.WriteInt(-math.MaxInt64)
-			},
-			wantOut: `-9223372036854775807`,
-		},
-		{
-			desc: "uint",
-			write: func(e *json.Encoder) {
-				e.WriteUint(math.MaxUint64)
-			},
-			wantOut: `18446744073709551615`,
-		},
-		{
-			desc: "empty object",
-			write: func(e *json.Encoder) {
-				e.StartObject()
-				e.EndObject()
-			},
-			wantOut: `{}`,
-		},
-		{
-			desc: "empty array",
-			write: func(e *json.Encoder) {
-				e.StartArray()
-				e.EndArray()
-			},
-			wantOut: `[]`,
-		},
-		{
-			desc: "object with one member",
-			write: func(e *json.Encoder) {
-				e.StartObject()
-				e.WriteName("hello")
-				e.WriteString("world")
-				e.EndObject()
-			},
-			wantOut: `{"hello":"world"}`,
-			wantOutIndent: `{
-	"hello": "world"
-}`,
-		},
-		{
-			desc: "array with one member",
-			write: func(e *json.Encoder) {
-				e.StartArray()
-				e.WriteNull()
-				e.EndArray()
-			},
-			wantOut: `[null]`,
-			wantOutIndent: `[
-	null
-]`,
-		},
-		{
-			desc: "simple object",
-			write: func(e *json.Encoder) {
-				e.StartObject()
-				{
-					e.WriteName("null")
-					e.WriteNull()
-				}
-				{
-					e.WriteName("bool")
-					e.WriteBool(true)
-				}
-				{
-					e.WriteName("string")
-					e.WriteString("hello")
-				}
-				{
-					e.WriteName("float")
-					e.WriteFloat(6.28318, 64)
-				}
-				{
-					e.WriteName("int")
-					e.WriteInt(42)
-				}
-				{
-					e.WriteName("uint")
-					e.WriteUint(47)
-				}
-				e.EndObject()
-			},
-			wantOut: `{"null":null,"bool":true,"string":"hello","float":6.28318,"int":42,"uint":47}`,
-			wantOutIndent: `{
-	"null": null,
-	"bool": true,
-	"string": "hello",
-	"float": 6.28318,
-	"int": 42,
-	"uint": 47
-}`,
-		},
-		{
-			desc: "simple array",
-			write: func(e *json.Encoder) {
-				e.StartArray()
-				{
-					e.WriteString("hello")
-					e.WriteFloat(6.28318, 32)
-					e.WriteInt(42)
-					e.WriteUint(47)
-					e.WriteBool(true)
-					e.WriteNull()
-				}
-				e.EndArray()
-			},
-			wantOut: `["hello",6.28318,42,47,true,null]`,
-			wantOutIndent: `[
-	"hello",
-	6.28318,
-	42,
-	47,
-	true,
-	null
-]`,
-		},
-		{
-			desc: "fancy object",
-			write: func(e *json.Encoder) {
-				e.StartObject()
-				{
-					e.WriteName("object0")
-					e.StartObject()
-					e.EndObject()
-				}
-				{
-					e.WriteName("array0")
-					e.StartArray()
-					e.EndArray()
-				}
-				{
-					e.WriteName("object1")
-					e.StartObject()
-					{
-						e.WriteName("null")
-						e.WriteNull()
-					}
-					{
-						e.WriteName("object1-1")
-						e.StartObject()
-						{
-							e.WriteName("bool")
-							e.WriteBool(false)
-						}
-						{
-							e.WriteName("float")
-							e.WriteFloat(3.14159, 32)
-						}
-						e.EndObject()
-					}
-					e.EndObject()
-				}
-				{
-					e.WriteName("array1")
-					e.StartArray()
-					{
-						e.WriteNull()
-						e.StartObject()
-						e.EndObject()
-						e.StartObject()
-						{
-							e.WriteName("hello")
-							e.WriteString("world")
-						}
-						{
-							e.WriteName("hola")
-							e.WriteString("mundo")
-						}
-						e.EndObject()
-						e.StartArray()
-						{
-							e.WriteUint(1)
-							e.WriteUint(0)
-							e.WriteUint(1)
-						}
-						e.EndArray()
-					}
-					e.EndArray()
-				}
-				e.EndObject()
-			},
-			wantOutIndent: `{
-	"object0": {},
-	"array0": [],
-	"object1": {
-		"null": null,
-		"object1-1": {
-			"bool": false,
-			"float": 3.14159
-		}
-	},
-	"array1": [
-		null,
-		{},
-		{
-			"hello": "world",
-			"hola": "mundo"
-		},
-		[
-			1,
-			0,
-			1
-		]
-	]
-}`,
-		}}
-
-	for _, tc := range tests {
-		t.Run(tc.desc, func(t *testing.T) {
-			if tc.wantOut != "" {
-				enc, err := json.NewEncoder(nil, "")
-				if err != nil {
-					t.Fatalf("NewEncoder() returned error: %v", err)
-				}
-				tc.write(enc)
-				got := string(enc.Bytes())
-				if got != tc.wantOut {
-					t.Errorf("%s:\n<got>:\n%v\n<want>\n%v\n", tc.desc, got, tc.wantOut)
-				}
-			}
-			if tc.wantOutIndent != "" {
-				enc, err := json.NewEncoder(nil, "\t")
-				if err != nil {
-					t.Fatalf("NewEncoder() returned error: %v", err)
-				}
-				tc.write(enc)
-				got, want := string(enc.Bytes()), tc.wantOutIndent
-				if got != want {
-					t.Errorf("%s(indent):\n<got>:\n%v\n<want>\n%v\n<diff -want +got>\n%v\n",
-						tc.desc, got, want, cmp.Diff(want, got, splitLines))
-				}
-			}
-		})
-	}
-}
-
-func TestWriteStringError(t *testing.T) {
-	tests := []string{"abc\xff"}
-
-	for _, in := range tests {
-		t.Run(in, func(t *testing.T) {
-			enc, err := json.NewEncoder(nil, "")
-			if err != nil {
-				t.Fatalf("NewEncoder() returned error: %v", err)
-			}
-			if err := enc.WriteString(in); err == nil {
-				t.Errorf("WriteString(%v): got nil error, want error", in)
-			}
-		})
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/gotest/ya.make b/vendor/google.golang.org/protobuf/internal/encoding/json/gotest/ya.make
deleted file mode 100644
index 8290d39c91..0000000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/json/gotest/ya.make
+++ /dev/null
@@ -1,5 +0,0 @@
-GO_TEST_FOR(vendor/google.golang.org/protobuf/internal/encoding/json)
-
-LICENSE(BSD-3-Clause)
-
-END()
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/ya.make b/vendor/google.golang.org/protobuf/internal/encoding/json/ya.make
index 7c858fb5a9..4f0b79391e 100644
--- a/vendor/google.golang.org/protobuf/internal/encoding/json/ya.make
+++ b/vendor/google.golang.org/protobuf/internal/encoding/json/ya.make
@@ -10,12 +10,4 @@ SRCS(
     encode.go
 )
 
-GO_XTEST_SRCS(
-    bench_test.go
-    decode_test.go
-    encode_test.go
-)
-
 END()
-
-RECURSE(gotest)
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/messageset/ya.make b/vendor/google.golang.org/protobuf/internal/encoding/messageset/ya.make
index 78df562dee..3681a9a476 100644
--- a/vendor/google.golang.org/protobuf/internal/encoding/messageset/ya.make
+++ b/vendor/google.golang.org/protobuf/internal/encoding/messageset/ya.make
@@ -2,6 +2,8 @@ GO_LIBRARY()
 
 LICENSE(BSD-3-Clause)
 
-SRCS(messageset.go)
+SRCS(
+    messageset.go
+)
 
 END()
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/tag/gotest/ya.make b/vendor/google.golang.org/protobuf/internal/encoding/tag/gotest/ya.make
deleted file mode 100644
index 0bc406ead2..0000000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/tag/gotest/ya.make
+++ /dev/null
@@ -1,5 +0,0 @@
-GO_TEST_FOR(vendor/google.golang.org/protobuf/internal/encoding/tag)
-
-LICENSE(BSD-3-Clause)
-
-END()
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/tag/tag_test.go b/vendor/google.golang.org/protobuf/internal/encoding/tag/tag_test.go
deleted file mode 100644
index e904a7b6bf..0000000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/tag/tag_test.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package tag_test
-
-import (
-	"reflect"
-	"testing"
-
-	"google.golang.org/protobuf/internal/encoding/tag"
-	"google.golang.org/protobuf/internal/filedesc"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/reflect/protodesc"
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-func Test(t *testing.T) {
-	fd := new(filedesc.Field)
-	fd.L0.ParentFile = filedesc.SurrogateProto3
-	fd.L0.FullName = "foo_field"
-	fd.L1.Number = 1337
-	fd.L1.Cardinality = protoreflect.Repeated
-	fd.L1.Kind = protoreflect.BytesKind
-	fd.L1.Default = filedesc.DefaultValue(protoreflect.ValueOf([]byte("hello, \xde\xad\xbe\xef\n")), nil)
-
-	// Marshal test.
-	gotTag := tag.Marshal(fd, "")
-	wantTag := `bytes,1337,rep,name=foo_field,json=fooField,proto3,def=hello, \336\255\276\357\n`
-	if gotTag != wantTag {
-		t.Errorf("Marshal() = `%v`, want `%v`", gotTag, wantTag)
-	}
-
-	// Unmarshal test.
-	gotFD := tag.Unmarshal(wantTag, reflect.TypeOf([]byte{}), nil)
-	wantFD := fd
-	if !proto.Equal(protodesc.ToFieldDescriptorProto(gotFD), protodesc.ToFieldDescriptorProto(wantFD)) {
-		t.Errorf("Umarshal() mismatch:\ngot  %v\nwant %v", gotFD, wantFD)
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/tag/ya.make b/vendor/google.golang.org/protobuf/internal/encoding/tag/ya.make
index 956490c6fc..12d85eb139 100644
--- a/vendor/google.golang.org/protobuf/internal/encoding/tag/ya.make
+++ b/vendor/google.golang.org/protobuf/internal/encoding/tag/ya.make
@@ -2,10 +2,8 @@ GO_LIBRARY()
 
 LICENSE(BSD-3-Clause)
 
-SRCS(tag.go)
-
-GO_XTEST_SRCS(tag_test.go)
+SRCS(
+    tag.go
+)
 
 END()
-
-RECURSE(gotest)
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_test.go b/vendor/google.golang.org/protobuf/internal/encoding/text/decode_test.go
deleted file mode 100644
index 7c705ab515..0000000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_test.go
+++ /dev/null
@@ -1,1955 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package text_test
-
-import (
-	"fmt"
-	"math"
-	"strings"
-	"testing"
-	"unicode/utf8"
-
-	"github.com/google/go-cmp/cmp"
-
-	"google.golang.org/protobuf/internal/encoding/text"
-	"google.golang.org/protobuf/internal/flags"
-)
-
-var eofErr = text.ErrUnexpectedEOF.Error()
-
-type R struct {
-	// K is expected Kind of the returned Token object from calling Decoder.Read.
-	K text.Kind
-	// E is expected error substring from calling Decoder.Read if set.
-	E string
-	// T contains NT (if K is Name) or ST (if K is Scalar) or nil (others)
-	T interface{}
-	// P is expected Token.Pos if set > 0.
-	P int
-	// RS is expected result from Token.RawString() if not empty.
-	RS string
-}
-
-// NT contains data for checking against a name token.
-type NT struct {
-	K text.NameKind
-	// Sep is true if name token should have separator character, else false.
-	Sep bool
-	// If K is IdentName or TypeName, invoke corresponding getter and compare against this field.
-	S string
-	// If K is FieldNumber, invoke getter and compare against this field.
-	N int32
-}
-
-// ST contains data for checking against a scalar token.
-type ST struct {
-	// checker that is expected to return OK.
-	ok checker
-	// checker that is expected to return not OK.
-	nok checker
-}
-
-// checker provides API for the token wrapper API call types Str, Enum, Bool,
-// Uint64, Uint32, Int64, Int32, Float64, Float32.
-type checker interface {
-	// checkOk checks and expects for token API call to return ok and compare
-	// against implementation-stored value. Returns empty string if success,
-	// else returns error message describing the error.
-	checkOk(text.Token) string
-	// checkNok checks and expects for token API call to return not ok. Returns
-	// empty string if success, else returns error message describing the error.
-	checkNok(text.Token) string
-}
-
-type Str struct {
-	val string
-}
-
-func (s Str) checkOk(tok text.Token) string {
-	got, ok := tok.String()
-	if !ok {
-		return fmt.Sprintf("Token.String() returned not OK for token: %v", tok.RawString())
-	}
-	if got != s.val {
-		return fmt.Sprintf("Token.String() got %q want %q for token: %v", got, s.val, tok.RawString())
-	}
-	return ""
-}
-
-func (s Str) checkNok(tok text.Token) string {
-	if _, ok := tok.String(); ok {
-		return fmt.Sprintf("Token.String() returned OK for token: %v", tok.RawString())
-	}
-	return ""
-}
-
-type Enum struct {
-	val string
-}
-
-func (e Enum) checkOk(tok text.Token) string {
-	got, ok := tok.Enum()
-	if !ok {
-		return fmt.Sprintf("Token.Enum() returned not OK for token: %v", tok.RawString())
-	}
-	if got != e.val {
-		return fmt.Sprintf("Token.Enum() got %q want %q for token: %v", got, e.val, tok.RawString())
-	}
-	return ""
-}
-
-func (e Enum) checkNok(tok text.Token) string {
-	if _, ok := tok.Enum(); ok {
-		return fmt.Sprintf("Token.Enum() returned OK for token: %v", tok.RawString())
-	}
-	return ""
-}
-
-type Bool struct {
-	val bool
-}
-
-func (b Bool) checkOk(tok text.Token) string {
-	got, ok := tok.Bool()
-	if !ok {
-		return fmt.Sprintf("Token.Bool() returned not OK for token: %v", tok.RawString())
-	}
-	if got != b.val {
-		return fmt.Sprintf("Token.Bool() got %v want %v for token: %v", got, b.val, tok.RawString())
-	}
-	return ""
-}
-
-func (b Bool) checkNok(tok text.Token) string {
-	if _, ok := tok.Bool(); ok {
-		return fmt.Sprintf("Token.Bool() returned OK for token: %v", tok.RawString())
-	}
-	return ""
-}
-
-type Uint64 struct {
-	val uint64
-}
-
-func (n Uint64) checkOk(tok text.Token) string {
-	got, ok := tok.Uint64()
-	if !ok {
-		return fmt.Sprintf("Token.Uint64() returned not OK for token: %v", tok.RawString())
-	}
-	if got != n.val {
-		return fmt.Sprintf("Token.Uint64() got %v want %v for token: %v", got, n.val, tok.RawString())
-	}
-	return ""
-}
-
-func (n Uint64) checkNok(tok text.Token) string {
-	if _, ok := tok.Uint64(); ok {
-		return fmt.Sprintf("Token.Uint64() returned OK for token: %v", tok.RawString())
-	}
-	return ""
-}
-
-type Uint32 struct {
-	val uint32
-}
-
-func (n Uint32) checkOk(tok text.Token) string {
-	got, ok := tok.Uint32()
-	if !ok {
-		return fmt.Sprintf("Token.Uint32() returned not OK for token: %v", tok.RawString())
-	}
-	if got != n.val {
-		return fmt.Sprintf("Token.Uint32() got %v want %v for token: %v", got, n.val, tok.RawString())
-	}
-	return ""
-}
-
-func (n Uint32) checkNok(tok text.Token) string {
-	if _, ok := tok.Uint32(); ok {
-		return fmt.Sprintf("Token.Uint32() returned OK for token: %v", tok.RawString())
-	}
-	return ""
-}
-
-type Int64 struct {
-	val int64
-}
-
-func (n Int64) checkOk(tok text.Token) string {
-	got, ok := tok.Int64()
-	if !ok {
-		return fmt.Sprintf("Token.Int64() returned not OK for token: %v", tok.RawString())
-	}
-	if got != n.val {
-		return fmt.Sprintf("Token.Int64() got %v want %v for token: %v", got, n.val, tok.RawString())
-	}
-	return ""
-}
-
-func (n Int64) checkNok(tok text.Token) string {
-	if _, ok := tok.Int64(); ok {
-		return fmt.Sprintf("Token.Int64() returned OK for token: %v", tok.RawString())
-	}
-	return ""
-}
-
-type Int32 struct {
-	val int32
-}
-
-func (n Int32) checkOk(tok text.Token) string {
-	got, ok := tok.Int32()
-	if !ok {
-		return fmt.Sprintf("Token.Int32() returned not OK for token: %v", tok.RawString())
-	}
-	if got != n.val {
-		return fmt.Sprintf("Token.Int32() got %v want %v for token: %v", got, n.val, tok.RawString())
-	}
-	return ""
-}
-
-func (n Int32) checkNok(tok text.Token) string {
-	if _, ok := tok.Int32(); ok {
-		return fmt.Sprintf("Token.Int32() returned OK for token: %v", tok.RawString())
-	}
-	return ""
-}
-
-type Float64 struct {
-	val float64
-}
-
-func (n Float64) checkOk(tok text.Token) string {
-	got, ok := tok.Float64()
-	if !ok {
-		return fmt.Sprintf("Token.Float64() returned not OK for token: %v", tok.RawString())
-	}
-	if math.Float64bits(got) != math.Float64bits(n.val) {
-		return fmt.Sprintf("Token.Float64() got %v want %v for token: %v", got, n.val, tok.RawString())
-	}
-	return ""
-}
-
-func (n Float64) checkNok(tok text.Token) string {
-	if _, ok := tok.Float64(); ok {
-		return fmt.Sprintf("Token.Float64() returned OK for token: %v", tok.RawString())
-	}
-	return ""
-}
-
-type Float32 struct {
-	val float32
-}
-
-func (n Float32) checkOk(tok text.Token) string {
-	got, ok := tok.Float32()
-	if !ok {
-		return fmt.Sprintf("Token.Float32() returned not OK for token: %v", tok.RawString())
-	}
-	if math.Float32bits(got) != math.Float32bits(n.val) {
-		return fmt.Sprintf("Token.Float32() got %v want %v for token: %v", got, n.val, tok.RawString())
-	}
-	return ""
-}
-
-func (n Float32) checkNok(tok text.Token) string {
-	if _, ok := tok.Float32(); ok {
-		return fmt.Sprintf("Token.Float32() returned OK for token: %v", tok.RawString())
-	}
-	return ""
-}
-
-func TestDecoder(t *testing.T) {
-	const space = " \n\r\t"
-	tests := []struct {
-		in string
-		// want is a list of expected Tokens returned from calling Decoder.Read.
-		// An item makes the test code invoke Decoder.Read and compare against
-		// R.K and R.E. If R.K is Name, it compares
-		want []R
-	}{
-		{
-			in:   "",
-			want: []R{{K: text.EOF}},
-		},
-		{
-			in:   "# comment",
-			want: []R{{K: text.EOF}},
-		},
-		{
-			in:   space + "# comment" + space,
-			want: []R{{K: text.EOF}},
-		},
-		{
-			in:   space,
-			want: []R{{K: text.EOF, P: len(space)}},
-		},
-		{
-			// Calling Read after EOF will keep returning EOF for
-			// succeeding Read calls.
-			in: space,
-			want: []R{
-				{K: text.EOF},
-				{K: text.EOF},
-				{K: text.EOF},
-			},
-		},
-		{
-			// NUL is an invalid whitespace since C++ uses C-strings.
-			in:   "\x00",
-			want: []R{{E: "invalid field name: \x00"}},
-		},
-
-		// Field names.
-		{
-			in: "name",
-			want: []R{
-				{K: text.Name, T: NT{K: text.IdentName, S: "name"}, RS: "name"},
-				{E: eofErr},
-			},
-		},
-		{
-			in: space + "name:" + space,
-			want: []R{
-				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "name"}},
-				{E: eofErr},
-			},
-		},
-		{
-			in: space + "name" + space + ":" + space,
-			want: []R{
-				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "name"}},
-				{E: eofErr},
-			},
-		},
-		{
-			in: "name # comment",
-			want: []R{
-				{K: text.Name, T: NT{K: text.IdentName, S: "name"}},
-				{E: eofErr},
-			},
-		},
-		{
-			// Comments only extend until the newline.
-			in: "# comment \nname",
-			want: []R{
-				{K: text.Name, T: NT{K: text.IdentName, S: "name"}, P: 11},
-			},
-		},
-		{
-			in: "name # comment \n:",
-			want: []R{
-				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "name"}},
-			},
-		},
-		{
-			in: "name123",
-			want: []R{
-				{K: text.Name, T: NT{K: text.IdentName, S: "name123"}},
-			},
-		},
-		{
-			in: "name_123",
-			want: []R{
-				{K: text.Name, T: NT{K: text.IdentName, S: "name_123"}},
-			},
-		},
-		{
-			in: "_123",
-			want: []R{
-				{K: text.Name, T: NT{K: text.IdentName, S: "_123"}},
-			},
-		},
-		{
-			in:   ":",
-			want: []R{{E: "syntax error (line 1:1): invalid field name: :"}},
-		},
-		{
-			in:   "\n\n\n {",
-			want: []R{{E: "syntax error (line 4:2): invalid field name: {"}},
-		},
-		{
-			in:   "123name",
-			want: []R{{E: "invalid field name: 123name"}},
-		},
-		{
-			in:   `/`,
-			want: []R{{E: `invalid field name: /`}},
-		},
-		{
-			in:   `世界`,
-			want: []R{{E: `invalid field name: 世`}},
-		},
-		{
-			in:   `1a/b`,
-			want: []R{{E: `invalid field name: 1a`}},
-		},
-		{
-			in:   `1c\d`,
-			want: []R{{E: `invalid field name: 1c`}},
-		},
-		{
-			in:   "\x84f",
-			want: []R{{E: "invalid field name: \x84"}},
-		},
-		{
-			in:   "\uFFFDxxx",
-			want: []R{{E: "invalid field name: \uFFFD"}},
-		},
-		{
-			in:   "-a234567890123456789012345678901234567890abc",
-			want: []R{{E: "invalid field name: -a2345678901234567890123456789012…"}},
-		},
-		{
-			in: "[type]",
-			want: []R{
-				{K: text.Name, T: NT{K: text.TypeName, S: "type"}, RS: "[type]"},
-			},
-		},
-		{
-			// V1 allows this syntax. C++ does not, however, C++ also fails if
-			// field is Any and does not contain '/'.
-			in: "[/type]",
-			want: []R{
-				{K: text.Name, T: NT{K: text.TypeName, S: "/type"}},
-			},
-		},
-		{
-			in:   "[.type]",
-			want: []R{{E: "invalid type URL/extension field name: [.type]"}},
-		},
-		{
-			in: "[pkg.Foo.extension_field]",
-			want: []R{
-				{K: text.Name, T: NT{K: text.TypeName, S: "pkg.Foo.extension_field"}},
-			},
-		},
-		{
-			in: "[domain.com/type]",
-			want: []R{
-				{K: text.Name, T: NT{K: text.TypeName, S: "domain.com/type"}},
-			},
-		},
-		{
-			in: "[domain.com/pkg.type]",
-			want: []R{
-				{K: text.Name, T: NT{K: text.TypeName, S: "domain.com/pkg.type"}},
-			},
-		},
-		{
-			in: "[sub.domain.com\x2fpath\x2fto\x2fproto.package.name]",
-			want: []R{
-				{
-					K: text.Name,
-					T: NT{
-						K: text.TypeName,
-						S: "sub.domain.com/path/to/proto.package.name",
-					},
-					RS: "[sub.domain.com\x2fpath\x2fto\x2fproto.package.name]",
-				},
-			},
-		},
-		{
-			// V2 no longer allows a quoted string for the Any type URL.
-			in:   `["domain.com/pkg.type"]`,
-			want: []R{{E: `invalid type URL/extension field name: ["`}},
-		},
-		{
-			// V2 no longer allows a quoted string for the Any type URL.
-			in:   `['domain.com/pkg.type']`,
-			want: []R{{E: `invalid type URL/extension field name: ['`}},
-		},
-		{
-			in:   "[pkg.Foo.extension_field:",
-			want: []R{{E: "invalid type URL/extension field name: [pkg.Foo.extension_field:"}},
-		},
-		{
-			// V2 no longer allows whitespace within identifier "word".
-			in:   "[proto.packa ge.field]",
-			want: []R{{E: "invalid type URL/extension field name: [proto.packa g"}},
-		},
-		{
-			// V2 no longer allows comments within identifier "word".
-			in:   "[proto.packa # comment\n ge.field]",
-			want: []R{{E: "invalid type URL/extension field name: [proto.packa # comment\n g"}},
-		},
-		{
-			in:   "[proto.package.]",
-			want: []R{{E: "invalid type URL/extension field name: [proto.package."}},
-		},
-		{
-			in:   "[proto.package/]",
-			want: []R{{E: "invalid type URL/extension field name: [proto.package/"}},
-		},
-		{
-			in: `message_field{[bad@]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.MessageOpen},
-				{E: `invalid type URL/extension field name: [bad@`},
-			},
-		},
-		{
-			in: `message_field{[invalid//type]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.MessageOpen},
-				{E: `invalid type URL/extension field name: [invalid//`},
-			},
-		},
-		{
-			in: `message_field{[proto.package.]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.MessageOpen},
-				{E: `invalid type URL/extension field name: [proto.package.`},
-			},
-		},
-		{
-			in:   "[proto.package",
-			want: []R{{E: eofErr}},
-		},
-		{
-			in: "[" + space + "type" + space + "]" + space + ":",
-			want: []R{
-				{
-					K: text.Name,
-					T: NT{
-						K:   text.TypeName,
-						Sep: true,
-						S:   "type",
-					},
-					RS: "[" + space + "type" + space + "]",
-				},
-			},
-		},
-		{
-			// Whitespaces/comments are only allowed betweeb
-			in: "[" + space + "domain" + space + "." + space + "com # comment\n" +
-				"/" + "pkg" + space + "." + space + "type" + space + "]",
-			want: []R{
-				{K: text.Name, T: NT{K: text.TypeName, S: "domain.com/pkg.type"}},
-			},
-		},
-		{
-			in: "42",
-			want: []R{
-				{K: text.Name, T: NT{K: text.FieldNumber, N: 42}},
-			},
-		},
-		{
-			in:   "0x42:",
-			want: []R{{E: "invalid field number: 0x42"}},
-		},
-		{
-			in:   "042:",
-			want: []R{{E: "invalid field number: 042"}},
-		},
-		{
-			in:   "123.456:",
-			want: []R{{E: "invalid field number: 123.456"}},
-		},
-		{
-			in:   "-123",
-			want: []R{{E: "invalid field number: -123"}},
-		},
-		{
-			in:   "- \t 123.321e6",
-			want: []R{{E: "invalid field number: -123.321e6"}},
-		},
-		{
-			in:   "-",
-			want: []R{{E: "invalid field name: -"}},
-		},
-		{
-			in:   "- ",
-			want: []R{{E: "invalid field name: -"}},
-		},
-		{
-			in:   "- # negative\n 123",
-			want: []R{{E: "invalid field number: -123"}},
-		},
-		{
-			// Field number > math.MaxInt32.
-			in:   "2147483648:",
-			want: []R{{E: "invalid field number: 2147483648"}},
-		},
-
-		// String field value. More string parsing specific testing in
-		// TestUnmarshalString.
-		{
-			in: `name: "hello world"`,
-			want: []R{
-				{K: text.Name},
-				{
-					K:  text.Scalar,
-					T:  ST{ok: Str{"hello world"}, nok: Enum{}},
-					RS: `"hello world"`,
-				},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `name: 'hello'`,
-			want: []R{
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
-			},
-		},
-		{
-			in: `name: "hello'`,
-			want: []R{
-				{K: text.Name},
-				{E: eofErr},
-			},
-		},
-		{
-			in: `name: 'hello`,
-			want: []R{
-				{K: text.Name},
-				{E: eofErr},
-			},
-		},
-		{
-			// Field name without separator is ok. prototext package will need
-			// to determine that this is not valid for scalar values.
-			in: space + `name` + space + `"hello"` + space,
-			want: []R{
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
-			},
-		},
-		{
-			in: `name'hello'`,
-			want: []R{
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
-			},
-		},
-		{
-			in: `name: ` + space + `"hello"` + space + `,`,
-			want: []R{
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `name` + space + `:` + `"hello"` + space + `;` + space,
-			want: []R{
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `name:"hello" , ,`,
-			want: []R{
-				{K: text.Name},
-				{K: text.Scalar},
-				{E: "(line 1:16): invalid field name: ,"},
-			},
-		},
-		{
-			in: `name:"hello" , ;`,
-			want: []R{
-				{K: text.Name},
-				{K: text.Scalar},
-				{E: "(line 1:16): invalid field name: ;"},
-			},
-		},
-		{
-			in: `name:"hello" name:'world'`,
-			want: []R{
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Str{"world"}}},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `name:"hello", name:"world"`,
-			want: []R{
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Str{"world"}}},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `name:"hello"; name:"world",`,
-			want: []R{
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Str{"world"}}},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `foo:"hello"bar:"world"`,
-			want: []R{
-				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "foo"}},
-				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
-				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "bar"}},
-				{K: text.Scalar, T: ST{ok: Str{"world"}}},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `foo:"hello"[bar]:"world"`,
-			want: []R{
-				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "foo"}},
-				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
-				{K: text.Name, T: NT{K: text.TypeName, Sep: true, S: "bar"}},
-				{K: text.Scalar, T: ST{ok: Str{"world"}}},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `name:"foo"` + space + `"bar"` + space + `'qux'`,
-			want: []R{
-				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "name"}},
-				{K: text.Scalar, T: ST{ok: Str{"foobarqux"}}},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `name:"foo"'bar'"qux"`,
-			want: []R{
-				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "name"}},
-				{K: text.Scalar, T: ST{ok: Str{"foobarqux"}}},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `name:"foo"` + space + `"bar" # comment` + "\n'qux' # comment",
-			want: []R{
-				{K: text.Name, T: NT{K: text.IdentName, Sep: true, S: "name"}},
-				{K: text.Scalar, T: ST{ok: Str{"foobarqux"}}},
-				{K: text.EOF},
-			},
-		},
-
-		// Lists.
-		{
-			in: `name: [`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{E: eofErr},
-			},
-		},
-		{
-			in: `name: []`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.ListClose},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `name []`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.ListClose},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `name: [,`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{E: `(line 1:8): invalid scalar value: ,`},
-			},
-		},
-		{
-			in: `name: [0`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar},
-				{E: eofErr},
-			},
-		},
-		{
-			in: `name: [` + space + `"hello"` + space + `]` + space,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Str{"hello"}}, P: len(space) + 7},
-				{K: text.ListClose},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `name: ["hello",]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
-				{E: `invalid scalar value: ]`},
-			},
-		},
-		{
-			in: `name: ["foo"` + space + `'bar' "qux"]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Str{"foobarqux"}}},
-				{K: text.ListClose},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `name:` + space + `["foo",` + space + "'bar', # comment\n\n" + `"qux"]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Str{"foo"}}},
-				{K: text.Scalar, T: ST{ok: Str{"bar"}}},
-				{K: text.Scalar, T: ST{ok: Str{"qux"}}},
-				{K: text.ListClose},
-				{K: text.EOF},
-			},
-		},
-
-		{
-			// List within list is not allowed.
-			in: `name: [[]]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{E: `syntax error (line 1:8): invalid scalar value: [`},
-			},
-		},
-		{
-			// List items need to be separated by ,.
-			in: `name: ["foo" true]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Str{"foo"}}},
-				{E: `syntax error (line 1:14): unexpected character 't'`},
-			},
-		},
-		{
-			in: `name: ["foo"; "bar"]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Str{"foo"}}},
-				{E: `syntax error (line 1:13): unexpected character ';'`},
-			},
-		},
-		{
-			in: `name: ["foo", true, ENUM, 1.0]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Str{"foo"}}},
-				{K: text.Scalar, T: ST{ok: Enum{"true"}}},
-				{K: text.Scalar, T: ST{ok: Enum{"ENUM"}}},
-				{K: text.Scalar, T: ST{ok: Float32{1.0}}},
-				{K: text.ListClose},
-			},
-		},
-
-		// Boolean literal values.
-		{
-			in: `name: True`,
-			want: []R{
-				{K: text.Name},
-				{
-					K: text.Scalar,
-					T: ST{ok: Bool{true}},
-				},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `name false`,
-			want: []R{
-				{K: text.Name},
-				{
-					K: text.Scalar,
-					T: ST{ok: Bool{false}},
-				},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `name: [t, f, True, False, true, false, 1, 0, 0x01, 0x00, 01, 00]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Bool{true}}},
-				{K: text.Scalar, T: ST{ok: Bool{false}}},
-				{K: text.Scalar, T: ST{ok: Bool{true}}},
-				{K: text.Scalar, T: ST{ok: Bool{false}}},
-				{K: text.Scalar, T: ST{ok: Bool{true}}},
-				{K: text.Scalar, T: ST{ok: Bool{false}}},
-				{K: text.Scalar, T: ST{ok: Bool{true}}},
-				{K: text.Scalar, T: ST{ok: Bool{false}}},
-				{K: text.Scalar, T: ST{ok: Bool{true}}},
-				{K: text.Scalar, T: ST{ok: Bool{false}}},
-				{K: text.Scalar, T: ST{ok: Bool{true}}},
-				{K: text.Scalar, T: ST{ok: Bool{false}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			// Looks like boolean but not.
-			in: `name: [tRUe, falSE, -1, -0, -0x01, -0x00, -01, -00, 0.0]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{nok: Bool{}}},
-				{K: text.Scalar, T: ST{nok: Bool{}}},
-				{K: text.Scalar, T: ST{nok: Bool{}}},
-				{K: text.Scalar, T: ST{nok: Bool{}}},
-				{K: text.Scalar, T: ST{nok: Bool{}}},
-				{K: text.Scalar, T: ST{nok: Bool{}}},
-				{K: text.Scalar, T: ST{nok: Bool{}}},
-				{K: text.Scalar, T: ST{nok: Bool{}}},
-				{K: text.Scalar, T: ST{nok: Bool{}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `foo: true[bar] false`,
-			want: []R{
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Bool{true}}},
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Bool{false}}},
-			},
-		},
-
-		// Enum field values.
-		{
-			in: space + `name: ENUM`,
-			want: []R{
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Enum{"ENUM"}}},
-			},
-		},
-		{
-			in: space + `name:[TRUE, FALSE, T, F, t, f]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Enum{"TRUE"}}},
-				{K: text.Scalar, T: ST{ok: Enum{"FALSE"}}},
-				{K: text.Scalar, T: ST{ok: Enum{"T"}}},
-				{K: text.Scalar, T: ST{ok: Enum{"F"}}},
-				{K: text.Scalar, T: ST{ok: Enum{"t"}}},
-				{K: text.Scalar, T: ST{ok: Enum{"f"}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `foo: Enum1[bar]:Enum2`,
-			want: []R{
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Enum{"Enum1"}}},
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Enum{"Enum2"}}},
-			},
-		},
-		{
-			// Invalid enum values.
-			in: `name: [-inf, -foo, "string", 42, 1.0, 0x47]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{nok: Enum{}}},
-				{K: text.Scalar, T: ST{nok: Enum{}}},
-				{K: text.Scalar, T: ST{nok: Enum{}}},
-				{K: text.Scalar, T: ST{nok: Enum{}}},
-				{K: text.Scalar, T: ST{nok: Enum{}}},
-				{K: text.Scalar, T: ST{nok: Enum{}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `name: true.`,
-			want: []R{
-				{K: text.Name},
-				{E: `invalid scalar value: true.`},
-			},
-		},
-
-		// Numeric values.
-		{
-			in: `nums:42 nums:0x2A nums:052`,
-			want: []R{
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Uint64{42}}},
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Uint64{42}}},
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Uint64{42}}},
-			},
-		},
-		{
-			in: `nums:[-42, -0x2a, -052]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{nok: Uint64{}}},
-				{K: text.Scalar, T: ST{nok: Uint64{}}},
-				{K: text.Scalar, T: ST{nok: Uint64{}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `nums:[-42, -0x2a, -052]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Int64{-42}}},
-				{K: text.Scalar, T: ST{ok: Int64{-42}}},
-				{K: text.Scalar, T: ST{ok: Int64{-42}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `nums: [0,0x0,00,-9876543210,9876543210,0x0123456789abcdef,-0x0123456789abcdef,01234567,-01234567]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Uint64{0}}},
-				{K: text.Scalar, T: ST{ok: Int64{0}}},
-				{K: text.Scalar, T: ST{ok: Uint64{0}}},
-				{K: text.Scalar, T: ST{ok: Int64{-9876543210}}},
-				{K: text.Scalar, T: ST{ok: Uint64{9876543210}}},
-				{K: text.Scalar, T: ST{ok: Uint64{0x0123456789abcdef}}},
-				{K: text.Scalar, T: ST{ok: Int64{-0x0123456789abcdef}}},
-				{K: text.Scalar, T: ST{ok: Uint64{01234567}}},
-				{K: text.Scalar, T: ST{ok: Int64{-01234567}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `nums: [0,0x0,00,-876543210,876543210,0x01234,-0x01234,01234567,-01234567]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Uint32{0}}},
-				{K: text.Scalar, T: ST{ok: Int32{0}}},
-				{K: text.Scalar, T: ST{ok: Uint32{0}}},
-				{K: text.Scalar, T: ST{ok: Int32{-876543210}}},
-				{K: text.Scalar, T: ST{ok: Uint32{876543210}}},
-				{K: text.Scalar, T: ST{ok: Uint32{0x01234}}},
-				{K: text.Scalar, T: ST{ok: Int32{-0x01234}}},
-				{K: text.Scalar, T: ST{ok: Uint32{01234567}}},
-				{K: text.Scalar, T: ST{ok: Int32{-01234567}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `nums: [` +
-				fmt.Sprintf("%d", uint64(math.MaxUint64)) + `,` +
-				fmt.Sprintf("%d", uint32(math.MaxUint32)) + `,` +
-				fmt.Sprintf("%d", int64(math.MaxInt64)) + `,` +
-				fmt.Sprintf("%d", int64(math.MinInt64)) + `,` +
-				fmt.Sprintf("%d", int32(math.MaxInt32)) + `,` +
-				fmt.Sprintf("%d", int32(math.MinInt32)) +
-				`]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Uint64{math.MaxUint64}}},
-				{K: text.Scalar, T: ST{ok: Uint32{math.MaxUint32}}},
-				{K: text.Scalar, T: ST{ok: Int64{math.MaxInt64}}},
-				{K: text.Scalar, T: ST{ok: Int64{math.MinInt64}}},
-				{K: text.Scalar, T: ST{ok: Int32{math.MaxInt32}}},
-				{K: text.Scalar, T: ST{ok: Int32{math.MinInt32}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			// Integer exceeds range.
-			in: `nums: [` +
-				`18446744073709551616,` + // max uint64 + 1
-				fmt.Sprintf("%d", uint64(math.MaxUint32+1)) + `,` +
-				fmt.Sprintf("%d", uint64(math.MaxInt64+1)) + `,` +
-				`-9223372036854775809,` + // min int64 - 1
-				fmt.Sprintf("%d", uint64(math.MaxInt32+1)) + `,` +
-				fmt.Sprintf("%d", int64(math.MinInt32-1)) + `` +
-				`]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{nok: Uint64{}}},
-				{K: text.Scalar, T: ST{nok: Uint32{}}},
-				{K: text.Scalar, T: ST{nok: Int64{}}},
-				{K: text.Scalar, T: ST{nok: Int64{}}},
-				{K: text.Scalar, T: ST{nok: Int32{}}},
-				{K: text.Scalar, T: ST{nok: Int32{}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `nums: [0xbeefbeef, 0xbeefbeefbeefbeef]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{
-					K: text.Scalar,
-					T: func() ST {
-						if flags.ProtoLegacy {
-							return ST{ok: Int32{-1091584273}}
-						}
-						return ST{nok: Int32{}}
-					}(),
-				},
-				{
-					K: text.Scalar,
-					T: func() ST {
-						if flags.ProtoLegacy {
-							return ST{ok: Int64{-4688318750159552785}}
-						}
-						return ST{nok: Int64{}}
-					}(),
-				},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `nums: [0.,0f,1f,10f,-0f,-1f,-10f,1.0,0.1e-3,1.5e+5,1e10,.0]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Float64{0.0}}},
-				{K: text.Scalar, T: ST{ok: Float64{0.0}}},
-				{K: text.Scalar, T: ST{ok: Float64{1.0}}},
-				{K: text.Scalar, T: ST{ok: Float64{10.0}}},
-				{K: text.Scalar, T: ST{ok: Float64{math.Copysign(0, -1)}}},
-				{K: text.Scalar, T: ST{ok: Float64{-1.0}}},
-				{K: text.Scalar, T: ST{ok: Float64{-10.0}}},
-				{K: text.Scalar, T: ST{ok: Float64{1.0}}},
-				{K: text.Scalar, T: ST{ok: Float64{0.1e-3}}},
-				{K: text.Scalar, T: ST{ok: Float64{1.5e+5}}},
-				{K: text.Scalar, T: ST{ok: Float64{1.0e+10}}},
-				{K: text.Scalar, T: ST{ok: Float64{0.0}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `nums: [0.,0f,1f,10f,-0f,-1f,-10f,1.0,0.1e-3,1.5e+5,1e10,.0]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Float32{0.0}}},
-				{K: text.Scalar, T: ST{ok: Float32{0.0}}},
-				{K: text.Scalar, T: ST{ok: Float32{1.0}}},
-				{K: text.Scalar, T: ST{ok: Float32{10.0}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Copysign(0, -1))}}},
-				{K: text.Scalar, T: ST{ok: Float32{-1.0}}},
-				{K: text.Scalar, T: ST{ok: Float32{-10.0}}},
-				{K: text.Scalar, T: ST{ok: Float32{1.0}}},
-				{K: text.Scalar, T: ST{ok: Float32{0.1e-3}}},
-				{K: text.Scalar, T: ST{ok: Float32{1.5e+5}}},
-				{K: text.Scalar, T: ST{ok: Float32{1.0e+10}}},
-				{K: text.Scalar, T: ST{ok: Float32{0.0}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `nums: [0.,1f,10F,1e1,1.10]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{nok: Int64{}}},
-				{K: text.Scalar, T: ST{nok: Int64{}}},
-				{K: text.Scalar, T: ST{nok: Int64{}}},
-				{K: text.Scalar, T: ST{nok: Int64{}}},
-				{K: text.Scalar, T: ST{nok: Int64{}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `nums: [0.,1f,10F,1e1,1.10]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{nok: Int32{}}},
-				{K: text.Scalar, T: ST{nok: Int32{}}},
-				{K: text.Scalar, T: ST{nok: Int32{}}},
-				{K: text.Scalar, T: ST{nok: Int32{}}},
-				{K: text.Scalar, T: ST{nok: Int32{}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `nums: [0.,1f,10F,1e1,1.10]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{nok: Uint64{}}},
-				{K: text.Scalar, T: ST{nok: Uint64{}}},
-				{K: text.Scalar, T: ST{nok: Uint64{}}},
-				{K: text.Scalar, T: ST{nok: Uint64{}}},
-				{K: text.Scalar, T: ST{nok: Uint64{}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `nums: [0.,1f,10F,1e1,1.10]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{nok: Uint32{}}},
-				{K: text.Scalar, T: ST{nok: Uint32{}}},
-				{K: text.Scalar, T: ST{nok: Uint32{}}},
-				{K: text.Scalar, T: ST{nok: Uint32{}}},
-				{K: text.Scalar, T: ST{nok: Uint32{}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `nums: [` +
-				fmt.Sprintf("%g", math.MaxFloat32) + `,` +
-				fmt.Sprintf("%g", -math.MaxFloat32) + `,` +
-				fmt.Sprintf("%g", math.MaxFloat32*2) + `,` +
-				fmt.Sprintf("%g", -math.MaxFloat32*2) + `,` +
-				`3.59539e+308,` + // math.MaxFloat64 * 2
-				`-3.59539e+308,` + // -math.MaxFloat64 * 2
-				fmt.Sprintf("%d000", uint64(math.MaxUint64)) +
-				`]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.MaxFloat32)}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(-math.MaxFloat32)}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(1))}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(-1))}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(1))}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(-1))}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.MaxUint64) * 1000}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `nums: [` +
-				fmt.Sprintf("%g", math.MaxFloat64) + `,` +
-				fmt.Sprintf("%g", -math.MaxFloat64) + `,` +
-				`3.59539e+308,` + // math.MaxFloat64 * 2
-				`-3.59539e+308,` + // -math.MaxFloat64 * 2
-				fmt.Sprintf("%d000", uint64(math.MaxUint64)) +
-				`]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Float64{math.MaxFloat64}}},
-				{K: text.Scalar, T: ST{ok: Float64{-math.MaxFloat64}}},
-				{K: text.Scalar, T: ST{ok: Float64{math.Inf(1)}}},
-				{K: text.Scalar, T: ST{ok: Float64{math.Inf(-1)}}},
-				{K: text.Scalar, T: ST{ok: Float64{float64(math.MaxUint64) * 1000}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			// -0 is only valid for signed types. It is not valid for unsigned types.
-			in: `num: [-0, -0]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{nok: Uint32{}}},
-				{K: text.Scalar, T: ST{nok: Uint64{}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			// -0 is only valid for signed types. It is not valid for unsigned types.
-			in: `num: [-0, -0]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Int32{0}}},
-				{K: text.Scalar, T: ST{ok: Int64{0}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			// Negative zeros on float64 should preserve sign bit.
-			in: `num: [-0, -.0]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Float64{math.Copysign(0, -1)}}},
-				{K: text.Scalar, T: ST{ok: Float64{math.Copysign(0, -1)}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			// Negative zeros on float32 should preserve sign bit.
-			in: `num: [-0, -.0]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Copysign(0, -1))}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Copysign(0, -1))}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `num: +0`,
-			want: []R{
-				{K: text.Name},
-				{E: `invalid scalar value: +`},
-			},
-		},
-		{
-			in: `num: 01.1234`,
-			want: []R{
-				{K: text.Name},
-				{E: `invalid scalar value: 01.1234`},
-			},
-		},
-		{
-			in: `num: 0x`,
-			want: []R{
-				{K: text.Name},
-				{E: `invalid scalar value: 0x`},
-			},
-		},
-		{
-			in: `num: 0xX`,
-			want: []R{
-				{K: text.Name},
-				{E: `invalid scalar value: 0xX`},
-			},
-		},
-		{
-			in: `num: 0800`,
-			want: []R{
-				{K: text.Name},
-				{E: `invalid scalar value: 0800`},
-			},
-		},
-		{
-			in: `num: 1.`,
-			want: []R{
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Float32{1.0}}},
-			},
-		},
-		{
-			in: `num: -.`,
-			want: []R{
-				{K: text.Name},
-				{E: `invalid scalar value: -.`},
-			},
-		},
-
-		// Float special literal values, case-insensitive match.
-		{
-			in: `name:[nan, NaN, Nan, NAN]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Float64{math.NaN()}}},
-				{K: text.Scalar, T: ST{ok: Float64{math.NaN()}}},
-				{K: text.Scalar, T: ST{ok: Float64{math.NaN()}}},
-				{K: text.Scalar, T: ST{ok: Float64{math.NaN()}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `name:[inf, INF, infinity, Infinity, INFinity]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Float64{math.Inf(1)}}},
-				{K: text.Scalar, T: ST{ok: Float64{math.Inf(1)}}},
-				{K: text.Scalar, T: ST{ok: Float64{math.Inf(1)}}},
-				{K: text.Scalar, T: ST{ok: Float64{math.Inf(1)}}},
-				{K: text.Scalar, T: ST{ok: Float64{math.Inf(1)}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `name:[-inf, -INF, -infinity, -Infinity, -INFinity]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Float64{math.Inf(-1)}}},
-				{K: text.Scalar, T: ST{ok: Float64{math.Inf(-1)}}},
-				{K: text.Scalar, T: ST{ok: Float64{math.Inf(-1)}}},
-				{K: text.Scalar, T: ST{ok: Float64{math.Inf(-1)}}},
-				{K: text.Scalar, T: ST{ok: Float64{math.Inf(-1)}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `name:[nan, NaN, Nan, NAN]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.NaN())}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.NaN())}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.NaN())}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.NaN())}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `name:[inf, INF, infinity, Infinity, INFinity]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(1))}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(1))}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(1))}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(1))}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(1))}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			in: `name:[-inf, -INF, -infinity, -Infinity, -INFinity]`,
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(-1))}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(-1))}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(-1))}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(-1))}}},
-				{K: text.Scalar, T: ST{ok: Float32{float32(math.Inf(-1))}}},
-				{K: text.ListClose},
-			},
-		},
-		{
-			// C++ permits this, but we currently reject this. It is easy to add
-			// if needed.
-			in: `name: -nan`,
-			want: []R{
-				{K: text.Name},
-				{K: text.Scalar, T: ST{nok: Float64{}}},
-			},
-		},
-		// Messages.
-		{
-			in: `m: {}`,
-			want: []R{
-				{K: text.Name},
-				{K: text.MessageOpen},
-				{K: text.MessageClose},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `m: <>`,
-			want: []R{
-				{K: text.Name},
-				{K: text.MessageOpen},
-				{K: text.MessageClose},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: space + `m {` + space + "\n# comment\n" + `}` + space,
-			want: []R{
-				{K: text.Name},
-				{K: text.MessageOpen},
-				{K: text.MessageClose},
-			},
-		},
-		{
-			in: `m { foo: < bar: "hello" > }`,
-			want: []R{
-				{K: text.Name, RS: "m"},
-				{K: text.MessageOpen},
-
-				{K: text.Name, RS: "foo"},
-				{K: text.MessageOpen},
-
-				{K: text.Name, RS: "bar"},
-				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
-
-				{K: text.MessageClose},
-
-				{K: text.MessageClose},
-			},
-		},
-		{
-			in: `list [ <s:"hello">, {s:"world"} ]`,
-			want: []R{
-				{K: text.Name, RS: "list"},
-				{K: text.ListOpen},
-
-				{K: text.MessageOpen},
-				{K: text.Name, RS: "s"},
-				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
-				{K: text.MessageClose},
-
-				{K: text.MessageOpen},
-				{K: text.Name, RS: "s"},
-				{K: text.Scalar, T: ST{ok: Str{"world"}}},
-				{K: text.MessageClose},
-
-				{K: text.ListClose},
-				{K: text.EOF},
-			},
-		},
-		{
-			in: `m: { >`,
-			want: []R{
-				{K: text.Name},
-				{K: text.MessageOpen},
-				{E: `mismatched close character '>'`},
-			},
-		},
-		{
-			in: `m: <s: "hello"}`,
-			want: []R{
-				{K: text.Name},
-				{K: text.MessageOpen},
-
-				{K: text.Name},
-				{K: text.Scalar, T: ST{ok: Str{"hello"}}},
-
-				{E: `mismatched close character '}'`},
-			},
-		},
-		{
-			in:   `{}`,
-			want: []R{{E: `invalid field name: {`}},
-		},
-		{
-			in: `
-m: {
-  foo: true;
-  bar: {
-	enum: ENUM
-	list: [ < >, { } ] ;
-  }
-  [qux]: "end"
-}
-				`,
-			want: []R{
-				{K: text.Name},
-				{K: text.MessageOpen},
-
-				{K: text.Name, RS: "foo"},
-				{K: text.Scalar, T: ST{ok: Bool{true}}},
-
-				{K: text.Name, RS: "bar"},
-				{K: text.MessageOpen},
-
-				{K: text.Name, RS: "enum"},
-				{K: text.Scalar, T: ST{ok: Enum{"ENUM"}}},
-
-				{K: text.Name, RS: "list"},
-				{K: text.ListOpen},
-				{K: text.MessageOpen},
-				{K: text.MessageClose},
-				{K: text.MessageOpen},
-				{K: text.MessageClose},
-				{K: text.ListClose},
-
-				{K: text.MessageClose},
-
-				{K: text.Name, RS: "[qux]"},
-				{K: text.Scalar, T: ST{ok: Str{"end"}}},
-
-				{K: text.MessageClose},
-				{K: text.EOF},
-			},
-		},
-
-		// Other syntax errors.
-		{
-			in: "x: -",
-			want: []R{
-				{K: text.Name},
-				{E: `syntax error (line 1:4): invalid scalar value: -`},
-			},
-		},
-		{
-			in: "x:[\"💩\"x",
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Str{"💩"}}, P: 3},
-				{E: `syntax error (line 1:7)`},
-			},
-		},
-		{
-			in: "x:\n\n[\"🔥🔥🔥\"x",
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Str{"🔥🔥🔥"}}, P: 5},
-				{E: `syntax error (line 3:7)`},
-			},
-		},
-		{
-			// multi-rune emojis; could be column:8
-			in: "x:[\"👍🏻👍🏿\"x",
-			want: []R{
-				{K: text.Name},
-				{K: text.ListOpen},
-				{K: text.Scalar, T: ST{ok: Str{"👍🏻👍🏿"}}, P: 3},
-				{E: `syntax error (line 1:10)`},
-			},
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run("", func(t *testing.T) {
-			tc := tc
-			in := []byte(tc.in)
-			dec := text.NewDecoder(in[:len(in):len(in)])
-			for i, want := range tc.want {
-				peekTok, peekErr := dec.Peek()
-				tok, err := dec.Read()
-				if err != nil {
-					if want.E == "" {
-						errorf(t, tc.in, "Read() got unexpected error: %v", err)
-					} else if !strings.Contains(err.Error(), want.E) {
-						errorf(t, tc.in, "Read() got %q, want %q", err, want.E)
-					}
-					return
-				}
-				if want.E != "" {
-					errorf(t, tc.in, "Read() got nil error, want %q", want.E)
-					return
-				}
-				gotK := tok.Kind()
-				if gotK != want.K {
-					errorf(t, tc.in, "Read() got %v, want %v", gotK, want.K)
-					return
-				}
-				checkToken(t, tok, i, want, tc.in)
-				if !cmp.Equal(tok, peekTok, cmp.Comparer(text.TokenEquals)) {
-					errorf(t, tc.in, "Peek() %+v != Read() token %+v", peekTok, tok)
-				}
-				if err != peekErr {
-					errorf(t, tc.in, "Peek() error %v != Read() error %v", err, peekErr)
-				}
-			}
-		})
-	}
-}
-
-func checkToken(t *testing.T, tok text.Token, idx int, r R, in string) {
-	// Validate Token.Pos() if R.P is set.
-	if r.P > 0 {
-		got := tok.Pos()
-		if got != r.P {
-			errorf(t, in, "want#%d: Token.Pos() got %v want %v", idx, got, r.P)
-		}
-	}
-
-	// Validate Token.RawString if R.RS is set.
-	if len(r.RS) > 0 {
-		got := tok.RawString()
-		if got != r.RS {
-			errorf(t, in, "want#%d: Token.RawString() got %v want %v", idx, got, r.P)
-		}
-	}
-
-	// Skip checking for Token details if r.T is not set.
-	if r.T == nil {
-		return
-	}
-
-	switch tok.Kind() {
-	case text.Name:
-		want := r.T.(NT)
-		kind := tok.NameKind()
-		if kind != want.K {
-			errorf(t, in, "want#%d: Token.NameKind() got %v want %v", idx, kind, want.K)
-			return
-		}
-		switch kind {
-		case text.IdentName:
-			got := tok.IdentName()
-			if got != want.S {
-				errorf(t, in, "want#%d: Token.IdentName() got %v want %v", idx, got, want.S)
-			}
-		case text.TypeName:
-			got := tok.TypeName()
-			if got != want.S {
-				errorf(t, in, "want#%d: Token.TypeName() got %v want %v", idx, got, want.S)
-			}
-		case text.FieldNumber:
-			got := tok.FieldNumber()
-			if got != want.N {
-				errorf(t, in, "want#%d: Token.FieldNumber() got %v want %v", idx, got, want.N)
-			}
-		}
-
-	case text.Scalar:
-		want := r.T.(ST)
-		if ok := want.ok; ok != nil {
-			if err := ok.checkOk(tok); err != "" {
-				errorf(t, in, "want#%d: %s", idx, err)
-			}
-		}
-		if nok := want.nok; nok != nil {
-			if err := nok.checkNok(tok); err != "" {
-				errorf(t, in, "want#%d: %s", idx, err)
-			}
-		}
-	}
-}
-
-func errorf(t *testing.T, in string, fmtStr string, args ...interface{}) {
-	t.Helper()
-	vargs := []interface{}{in}
-	for _, arg := range args {
-		vargs = append(vargs, arg)
-	}
-	t.Errorf("input:\n%s\n~end~\n"+fmtStr, vargs...)
-}
-
-func TestUnmarshalString(t *testing.T) {
-	tests := []struct {
-		in string
-		// want is expected string result.
-		want string
-		// err is expected error substring from calling DecodeString if set.
-		err string
-	}{
-		{
-			in: func() string {
-				var b []byte
-				for i := 0; i < utf8.RuneSelf; i++ {
-					switch i {
-					case 0, '\\', '\n', '\'': // these must be escaped, so ignore them
-					default:
-						b = append(b, byte(i))
-					}
-				}
-				return "'" + string(b) + "'"
-			}(),
-			want: "\x01\x02\x03\x04\x05\x06\a\b\t\v\f\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~\u007f",
-		},
-		{
-			in:  "'\xde\xad\xbe\xef'",
-			err: `invalid UTF-8 detected`,
-		},
-		{
-			// Valid UTF-8 wire encoding, but sub-optimal encoding.
-			in:  "'\xc0\x80'",
-			err: "invalid UTF-8 detected",
-		},
-		{
-			// Valid UTF-8 wire encoding, but invalid rune (surrogate pair).
-			in:  "'\xed\xa0\x80'",
-			err: "invalid UTF-8 detected",
-		},
-		{
-			// Valid UTF-8 wire encoding, but invalid rune (above max rune).
-			in:  "'\xf7\xbf\xbf\xbf'",
-			err: "invalid UTF-8 detected",
-		},
-		{
-			// Valid UTF-8 wire encoding of the RuneError rune.
-			in:   "'\xef\xbf\xbd'",
-			want: string(utf8.RuneError),
-		},
-		{
-			in:   "'hello\u1234world'",
-			want: "hello\u1234world",
-		},
-		{
-			in:   `'\"\'\\\?\a\b\n\r\t\v\f\1\12\123\xA\xaB\x12\uAb8f\U0010FFFF'`,
-			want: "\"'\\?\a\b\n\r\t\v\f\x01\nS\n\xab\x12\uab8f\U0010ffff",
-		},
-		{
-			in:  `str: '\8'`,
-			err: `invalid escape code "\\8" in string`,
-		},
-		{
-			in:   `'\1x'`,
-			want: "\001x",
-		},
-		{
-			in:   `'\12x'`,
-			want: "\012x",
-		},
-		{
-			in:   `'\123x'`,
-			want: "\123x",
-		},
-		{
-			in:   `'\1234x'`,
-			want: "\1234x",
-		},
-		{
-			in:   `'\1'`,
-			want: "\001",
-		},
-		{
-			in:   `'\12'`,
-			want: "\012",
-		},
-		{
-			in:   `'\123'`,
-			want: "\123",
-		},
-		{
-			in:   `'\1234'`,
-			want: "\1234",
-		},
-		{
-			in:   `'\377'`,
-			want: "\377",
-		},
-		{
-			// Overflow octal escape.
-			in:  `'\400'`,
-			err: `invalid octal escape code "\\400" in string`,
-		},
-		{
-			in:   `'\xfx'`,
-			want: "\x0fx",
-		},
-		{
-			in:   `'\xffx'`,
-			want: "\xffx",
-		},
-		{
-			in:   `'\xfffx'`,
-			want: "\xfffx",
-		},
-		{
-			in:   `'\xf'`,
-			want: "\x0f",
-		},
-		{
-			in:   `'\xff'`,
-			want: "\xff",
-		},
-		{
-			in:   `'\xfff'`,
-			want: "\xfff",
-		},
-		{
-			in:  `'\xz'`,
-			err: `invalid hex escape code "\\x" in string`,
-		},
-		{
-			in:  `'\uPo'`,
-			err: eofErr,
-		},
-		{
-			in:  `'\uPoo'`,
-			err: `invalid Unicode escape code "\\uPoo'" in string`,
-		},
-		{
-			in:  `str: '\uPoop'`,
-			err: `invalid Unicode escape code "\\uPoop" in string`,
-		},
-		{
-			// Unmatched surrogate pair.
-			in:  `str: '\uDEAD'`,
-			err: `unexpected EOF`, // trying to reader other half
-		},
-		{
-			// Surrogate pair with invalid other half.
-			in:  `str: '\uDEAD\u0000'`,
-			err: `invalid Unicode escape code "\\u0000" in string`,
-		},
-		{
-			// Properly matched surrogate pair.
-			in:   `'\uD800\uDEAD'`,
-			want: "𐊭",
-		},
-		{
-			// Overflow on Unicode rune.
-			in:  `'\U00110000'`,
-			err: `invalid Unicode escape code "\\U00110000" in string`,
-		},
-		{
-			in:  `'\z'`,
-			err: `invalid escape code "\\z" in string`,
-		},
-		{
-			// Strings cannot have NUL literal since C-style strings forbid them.
-			in:  "'\x00'",
-			err: `invalid character '\x00' in string`,
-		},
-		{
-			// Strings cannot have newline literal. The C++ permits them if an
-			// option is specified to allow them. In Go, we always forbid them.
-			in:  "'\n'",
-			err: `invalid character '\n' in string`,
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run("", func(t *testing.T) {
-			got, err := text.UnmarshalString(tc.in)
-			if err != nil {
-				if tc.err == "" {
-					errorf(t, tc.in, "UnmarshalString() got unexpected error: %q", err)
-				} else if !strings.Contains(err.Error(), tc.err) {
-					errorf(t, tc.in, "UnmarshalString() error got %q, want %q", err, tc.err)
-				}
-				return
-			}
-			if tc.err != "" {
-				errorf(t, tc.in, "UnmarshalString() got nil error, want %q", tc.err)
-				return
-			}
-			if got != tc.want {
-				errorf(t, tc.in, "UnmarshalString()\n[got]\n%s\n[want]\n%s", got, tc.want)
-			}
-		})
-	}
-}
-
-// Tests line and column number produced by Decoder.Position.
-func TestPosition(t *testing.T) {
-	dec := text.NewDecoder([]byte("0123456789\n12345\n789"))
-
-	tests := []struct {
-		pos int
-		row int
-		col int
-	}{
-		{
-			pos: 0,
-			row: 1,
-			col: 1,
-		},
-		{
-			pos: 10,
-			row: 1,
-			col: 11,
-		},
-		{
-			pos: 11,
-			row: 2,
-			col: 1,
-		},
-		{
-			pos: 18,
-			row: 3,
-			col: 2,
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run("", func(t *testing.T) {
-			row, col := dec.Position(tc.pos)
-			if row != tc.row || col != tc.col {
-				t.Errorf("Position(%d) got (%d,%d) want (%d,%d)", tc.pos, row, col, tc.row, tc.col)
-			}
-		})
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/encode_test.go b/vendor/google.golang.org/protobuf/internal/encoding/text/encode_test.go
deleted file mode 100644
index d9c5009833..0000000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/text/encode_test.go
+++ /dev/null
@@ -1,557 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package text_test
-
-import (
-	"math"
-	"strings"
-	"testing"
-	"unicode/utf8"
-
-	"github.com/google/go-cmp/cmp"
-
-	"google.golang.org/protobuf/internal/detrand"
-	"google.golang.org/protobuf/internal/encoding/text"
-)
-
-// Disable detrand to enable direct comparisons on outputs.
-func init() { detrand.Disable() }
-
-func TestEncoder(t *testing.T) {
-	tests := []encoderTestCase{
-		{
-			desc:          "no-opt",
-			write:         func(e *text.Encoder) {},
-			wantOut:       ``,
-			wantOutIndent: ``,
-		},
-		{
-			desc: "true",
-			write: func(e *text.Encoder) {
-				e.WriteName("bool")
-				e.WriteBool(true)
-			},
-			wantOut:       `bool:true`,
-			wantOutIndent: `bool: true`,
-		},
-		{
-			desc: "false",
-			write: func(e *text.Encoder) {
-				e.WriteName("bool")
-				e.WriteBool(false)
-			},
-			wantOut:       `bool:false`,
-			wantOutIndent: `bool: false`,
-		},
-		{
-			desc: "bracket name",
-			write: func(e *text.Encoder) {
-				e.WriteName("[extension]")
-				e.WriteString("hello")
-			},
-			wantOut:       `[extension]:"hello"`,
-			wantOutIndent: `[extension]: "hello"`,
-		},
-		{
-			desc: "numeric name",
-			write: func(e *text.Encoder) {
-				e.WriteName("01234")
-				e.WriteString("hello")
-			},
-			wantOut:       `01234:"hello"`,
-			wantOutIndent: `01234: "hello"`,
-		},
-		{
-			desc: "string",
-			write: func(e *text.Encoder) {
-				e.WriteName("str")
-				e.WriteString("hello world")
-			},
-			wantOut:       `str:"hello world"`,
-			wantOutIndent: `str: "hello world"`,
-		},
-		{
-			desc: "enum",
-			write: func(e *text.Encoder) {
-				e.WriteName("enum")
-				e.WriteLiteral("ENUM_VALUE")
-			},
-			wantOut:       `enum:ENUM_VALUE`,
-			wantOutIndent: `enum: ENUM_VALUE`,
-		},
-		{
-			desc: "float64",
-			write: func(e *text.Encoder) {
-				e.WriteName("float64")
-				e.WriteFloat(1.0199999809265137, 64)
-			},
-			wantOut:       `float64:1.0199999809265137`,
-			wantOutIndent: `float64: 1.0199999809265137`,
-		},
-		{
-			desc: "float64 max value",
-			write: func(e *text.Encoder) {
-				e.WriteName("float64")
-				e.WriteFloat(math.MaxFloat64, 64)
-			},
-			wantOut:       `float64:1.7976931348623157e+308`,
-			wantOutIndent: `float64: 1.7976931348623157e+308`,
-		},
-		{
-			desc: "float64 min value",
-			write: func(e *text.Encoder) {
-				e.WriteName("float64")
-				e.WriteFloat(-math.MaxFloat64, 64)
-			},
-			wantOut:       `float64:-1.7976931348623157e+308`,
-			wantOutIndent: `float64: -1.7976931348623157e+308`,
-		},
-		{
-			desc: "float64 nan",
-			write: func(e *text.Encoder) {
-				e.WriteName("float64")
-				e.WriteFloat(math.NaN(), 64)
-			},
-			wantOut:       `float64:nan`,
-			wantOutIndent: `float64: nan`,
-		},
-		{
-			desc: "float64 inf",
-			write: func(e *text.Encoder) {
-				e.WriteName("float64")
-				e.WriteFloat(math.Inf(+1), 64)
-			},
-			wantOut:       `float64:inf`,
-			wantOutIndent: `float64: inf`,
-		},
-		{
-			desc: "float64 -inf",
-			write: func(e *text.Encoder) {
-				e.WriteName("float64")
-				e.WriteFloat(math.Inf(-1), 64)
-			},
-			wantOut:       `float64:-inf`,
-			wantOutIndent: `float64: -inf`,
-		},
-		{
-			desc: "float64 negative zero",
-			write: func(e *text.Encoder) {
-				e.WriteName("float64")
-				e.WriteFloat(math.Copysign(0, -1), 64)
-			},
-			wantOut:       `float64:-0`,
-			wantOutIndent: `float64: -0`,
-		},
-		{
-			desc: "float32",
-			write: func(e *text.Encoder) {
-				e.WriteName("float")
-				e.WriteFloat(1.02, 32)
-			},
-			wantOut:       `float:1.02`,
-			wantOutIndent: `float: 1.02`,
-		},
-		{
-			desc: "float32 max value",
-			write: func(e *text.Encoder) {
-				e.WriteName("float32")
-				e.WriteFloat(math.MaxFloat32, 32)
-			},
-			wantOut:       `float32:3.4028235e+38`,
-			wantOutIndent: `float32: 3.4028235e+38`,
-		},
-		{
-			desc: "float32 nan",
-			write: func(e *text.Encoder) {
-				e.WriteName("float32")
-				e.WriteFloat(math.NaN(), 32)
-			},
-			wantOut:       `float32:nan`,
-			wantOutIndent: `float32: nan`,
-		},
-		{
-			desc: "float32 inf",
-			write: func(e *text.Encoder) {
-				e.WriteName("float32")
-				e.WriteFloat(math.Inf(+1), 32)
-			},
-			wantOut:       `float32:inf`,
-			wantOutIndent: `float32: inf`,
-		},
-		{
-			desc: "float32 -inf",
-			write: func(e *text.Encoder) {
-				e.WriteName("float32")
-				e.WriteFloat(math.Inf(-1), 32)
-			},
-			wantOut:       `float32:-inf`,
-			wantOutIndent: `float32: -inf`,
-		},
-		{
-			desc: "float32 negative zero",
-			write: func(e *text.Encoder) {
-				e.WriteName("float32")
-				e.WriteFloat(math.Copysign(0, -1), 32)
-			},
-			wantOut:       `float32:-0`,
-			wantOutIndent: `float32: -0`,
-		},
-		{
-			desc: "int64 max value",
-			write: func(e *text.Encoder) {
-				e.WriteName("int")
-				e.WriteInt(math.MaxInt64)
-			},
-			wantOut:       `int:9223372036854775807`,
-			wantOutIndent: `int: 9223372036854775807`,
-		},
-		{
-			desc: "int64 min value",
-			write: func(e *text.Encoder) {
-				e.WriteName("int")
-				e.WriteInt(math.MinInt64)
-			},
-			wantOut:       `int:-9223372036854775808`,
-			wantOutIndent: `int: -9223372036854775808`,
-		},
-		{
-			desc: "uint",
-			write: func(e *text.Encoder) {
-				e.WriteName("uint")
-				e.WriteUint(math.MaxUint64)
-			},
-			wantOut:       `uint:18446744073709551615`,
-			wantOutIndent: `uint: 18446744073709551615`,
-		},
-		{
-			desc: "empty message field",
-			write: func(e *text.Encoder) {
-				e.WriteName("m")
-				e.StartMessage()
-				e.EndMessage()
-			},
-			wantOut:       `m:{}`,
-			wantOutIndent: `m: {}`,
-		},
-		{
-			desc: "multiple fields",
-			write: func(e *text.Encoder) {
-				e.WriteName("bool")
-				e.WriteBool(true)
-				e.WriteName("str")
-				e.WriteString("hello")
-				e.WriteName("str")
-				e.WriteString("world")
-				e.WriteName("m")
-				e.StartMessage()
-				e.EndMessage()
-				e.WriteName("[int]")
-				e.WriteInt(49)
-				e.WriteName("float64")
-				e.WriteFloat(1.00023e4, 64)
-				e.WriteName("101")
-				e.WriteString("unknown")
-			},
-			wantOut: `bool:true str:"hello" str:"world" m:{} [int]:49 float64:10002.3 101:"unknown"`,
-			wantOutIndent: `bool: true
-str: "hello"
-str: "world"
-m: {}
-[int]: 49
-float64: 10002.3
-101: "unknown"`,
-		},
-		{
-			desc: "populated message fields",
-			write: func(e *text.Encoder) {
-				e.WriteName("m1")
-				e.StartMessage()
-				{
-					e.WriteName("str")
-					e.WriteString("hello")
-				}
-				e.EndMessage()
-
-				e.WriteName("bool")
-				e.WriteBool(true)
-
-				e.WriteName("m2")
-				e.StartMessage()
-				{
-					e.WriteName("str")
-					e.WriteString("world")
-					e.WriteName("m2-1")
-					e.StartMessage()
-					e.EndMessage()
-					e.WriteName("m2-2")
-					e.StartMessage()
-					{
-						e.WriteName("[int]")
-						e.WriteInt(49)
-					}
-					e.EndMessage()
-					e.WriteName("float64")
-					e.WriteFloat(1.00023e4, 64)
-				}
-				e.EndMessage()
-
-				e.WriteName("101")
-				e.WriteString("unknown")
-			},
-			wantOut: `m1:{str:"hello"} bool:true m2:{str:"world" m2-1:{} m2-2:{[int]:49} float64:10002.3} 101:"unknown"`,
-			wantOutIndent: `m1: {
-	str: "hello"
-}
-bool: true
-m2: {
-	str: "world"
-	m2-1: {}
-	m2-2: {
-		[int]: 49
-	}
-	float64: 10002.3
-}
-101: "unknown"`,
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.desc, func(t *testing.T) {
-			runEncoderTest(t, tc, [2]byte{})
-
-			// Test using the angle brackets.
-			// Testcases should not contain characters '{' and '}'.
-			tc.wantOut = replaceDelims(tc.wantOut)
-			tc.wantOutIndent = replaceDelims(tc.wantOutIndent)
-			runEncoderTest(t, tc, [2]byte{'<', '>'})
-		})
-	}
-}
-
-type encoderTestCase struct {
-	desc          string
-	write         func(*text.Encoder)
-	wantOut       string
-	wantOutIndent string
-}
-
-func runEncoderTest(t *testing.T, tc encoderTestCase, delims [2]byte) {
-	t.Helper()
-
-	if tc.wantOut != "" {
-		enc, err := text.NewEncoder(nil, "", delims, false)
-		if err != nil {
-			t.Fatalf("NewEncoder returned error: %v", err)
-		}
-		tc.write(enc)
-		got := string(enc.Bytes())
-		if got != tc.wantOut {
-			t.Errorf("(compact)\n<got>\n%v\n<want>\n%v\n", got, tc.wantOut)
-		}
-	}
-	if tc.wantOutIndent != "" {
-		enc, err := text.NewEncoder(nil, "\t", delims, false)
-		if err != nil {
-			t.Fatalf("NewEncoder returned error: %v", err)
-		}
-		tc.write(enc)
-		got, want := string(enc.Bytes()), tc.wantOutIndent
-		if got != want {
-			t.Errorf("(multi-line)\n<got>\n%v\n<want>\n%v\n<diff -want +got>\n%v\n",
-				got, want, cmp.Diff(want, got))
-		}
-	}
-}
-
-func replaceDelims(s string) string {
-	s = strings.Replace(s, "{", "<", -1)
-	return strings.Replace(s, "}", ">", -1)
-}
-
-// Test for UTF-8 and ASCII outputs.
-func TestEncodeStrings(t *testing.T) {
-	tests := []struct {
-		in           string
-		wantOut      string
-		wantOutASCII string
-	}{
-		{
-			in:      `"`,
-			wantOut: `"\""`,
-		},
-		{
-			in:      `'`,
-			wantOut: `"'"`,
-		},
-		{
-			in:           "hello\u1234world",
-			wantOut:      "\"hello\u1234world\"",
-			wantOutASCII: `"hello\u1234world"`,
-		},
-		{
-			// String that has as few escaped characters as possible.
-			in: func() string {
-				var b []byte
-				for i := rune(0); i <= 0x00a0; i++ {
-					switch i {
-					case 0, '\\', '\n', '\'': // these must be escaped, so ignore them
-					default:
-						var r [utf8.UTFMax]byte
-						n := utf8.EncodeRune(r[:], i)
-						b = append(b, r[:n]...)
-					}
-				}
-				return string(b)
-			}(),
-			wantOut:      `"\x01\x02\x03\x04\x05\x06\x07\x08\t\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_` + "`" + `abcdefghijklmnopqrstuvwxyz{|}~\x7f\u0080\u0081\u0082\u0083\u0084\u0085\u0086\u0087\u0088\u0089\u008a\u008b\u008c\u008d\u008e\u008f\u0090\u0091\u0092\u0093\u0094\u0095\u0096\u0097\u0098\u0099\u009a\u009b\u009c\u009d\u009e\u009f` + "\u00a0" + `"`,
-			wantOutASCII: `"\x01\x02\x03\x04\x05\x06\x07\x08\t\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_` + "`" + `abcdefghijklmnopqrstuvwxyz{|}~\x7f\u0080\u0081\u0082\u0083\u0084\u0085\u0086\u0087\u0088\u0089\u008a\u008b\u008c\u008d\u008e\u008f\u0090\u0091\u0092\u0093\u0094\u0095\u0096\u0097\u0098\u0099\u009a\u009b\u009c\u009d\u009e\u009f\u00a0"`,
-		},
-		{
-			// Valid UTF-8 wire encoding of the RuneError rune.
-			in:           string(utf8.RuneError),
-			wantOut:      `"` + string(utf8.RuneError) + `"`,
-			wantOutASCII: `"\ufffd"`,
-		},
-		{
-			in:           "\"'\\?\a\b\n\r\t\v\f\x01\nS\n\xab\x12\uab8f\U0010ffff",
-			wantOut:      `"\"'\\?\x07\x08\n\r\t\x0b\x0c\x01\nS\n\xab\x12` + "\uab8f\U0010ffff" + `"`,
-			wantOutASCII: `"\"'\\?\x07\x08\n\r\t\x0b\x0c\x01\nS\n\xab\x12\uab8f\U0010ffff"`,
-		},
-		{
-			in:           "\001x",
-			wantOut:      `"\x01x"`,
-			wantOutASCII: `"\x01x"`,
-		},
-		{
-			in:           "\012x",
-			wantOut:      `"\nx"`,
-			wantOutASCII: `"\nx"`,
-		},
-		{
-			in:           "\123x",
-			wantOut:      `"Sx"`,
-			wantOutASCII: `"Sx"`,
-		},
-		{
-			in:           "\1234x",
-			wantOut:      `"S4x"`,
-			wantOutASCII: `"S4x"`,
-		},
-		{
-			in:           "\001",
-			wantOut:      `"\x01"`,
-			wantOutASCII: `"\x01"`,
-		},
-		{
-			in:           "\012",
-			wantOut:      `"\n"`,
-			wantOutASCII: `"\n"`,
-		},
-		{
-			in:           "\123",
-			wantOut:      `"S"`,
-			wantOutASCII: `"S"`,
-		},
-		{
-			in:           "\1234",
-			wantOut:      `"S4"`,
-			wantOutASCII: `"S4"`,
-		},
-		{
-			in:           "\377",
-			wantOut:      `"\xff"`,
-			wantOutASCII: `"\xff"`,
-		},
-		{
-			in:           "\x0fx",
-			wantOut:      `"\x0fx"`,
-			wantOutASCII: `"\x0fx"`,
-		},
-		{
-			in:           "\xffx",
-			wantOut:      `"\xffx"`,
-			wantOutASCII: `"\xffx"`,
-		},
-		{
-			in:           "\xfffx",
-			wantOut:      `"\xfffx"`,
-			wantOutASCII: `"\xfffx"`,
-		},
-		{
-			in:           "\x0f",
-			wantOut:      `"\x0f"`,
-			wantOutASCII: `"\x0f"`,
-		},
-		{
-			in:           "\x7f",
-			wantOut:      `"\x7f"`,
-			wantOutASCII: `"\x7f"`,
-		},
-		{
-			in:           "\xff",
-			wantOut:      `"\xff"`,
-			wantOutASCII: `"\xff"`,
-		},
-		{
-			in:           "\xfff",
-			wantOut:      `"\xfff"`,
-			wantOutASCII: `"\xfff"`,
-		},
-	}
-	for _, tc := range tests {
-		t.Run("", func(t *testing.T) {
-			if tc.wantOut != "" {
-				runEncodeStringsTest(t, tc.in, tc.wantOut, false)
-			}
-			if tc.wantOutASCII != "" {
-				runEncodeStringsTest(t, tc.in, tc.wantOutASCII, true)
-			}
-		})
-	}
-}
-
-func runEncodeStringsTest(t *testing.T, in string, want string, outputASCII bool) {
-	t.Helper()
-
-	charType := "UTF-8"
-	if outputASCII {
-		charType = "ASCII"
-	}
-
-	enc, err := text.NewEncoder(nil, "", [2]byte{}, outputASCII)
-	if err != nil {
-		t.Fatalf("[%s] NewEncoder returned error: %v", charType, err)
-	}
-	enc.WriteString(in)
-	got := string(enc.Bytes())
-	if got != want {
-		t.Errorf("[%s] WriteString(%q)\n<got>\n%v\n<want>\n%v\n", charType, in, got, want)
-	}
-}
-
-func TestReset(t *testing.T) {
-	enc, err := text.NewEncoder(nil, "\t", [2]byte{}, false)
-	if err != nil {
-		t.Fatalf("NewEncoder returned error: %v", err)
-	}
-
-	enc.WriteName("foo")
-	pos := enc.Snapshot()
-
-	// Attempt to write a message value.
-	enc.StartMessage()
-	enc.WriteName("bar")
-	enc.WriteUint(10)
-
-	// Reset the value and decided to write a string value instead.
-	enc.Reset(pos)
-	enc.WriteString("0123456789")
-
-	got := string(enc.Bytes())
-	want := `foo: "0123456789"`
-	if got != want {
-		t.Errorf("Reset did not restore given position:\n<got>\n%v\n<want>\n%v\n", got, want)
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/gotest/ya.make b/vendor/google.golang.org/protobuf/internal/encoding/text/gotest/ya.make
deleted file mode 100644
index c19bba9efd..0000000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/text/gotest/ya.make
+++ /dev/null
@@ -1,5 +0,0 @@
-GO_TEST_FOR(vendor/google.golang.org/protobuf/internal/encoding/text)
-
-LICENSE(BSD-3-Clause)
-
-END()
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/ya.make b/vendor/google.golang.org/protobuf/internal/encoding/text/ya.make
index d9fb283dd6..5665f82701 100644
--- a/vendor/google.golang.org/protobuf/internal/encoding/text/ya.make
+++ b/vendor/google.golang.org/protobuf/internal/encoding/text/ya.make
@@ -11,11 +11,4 @@ SRCS(
     encode.go
 )
 
-GO_XTEST_SRCS(
-    decode_test.go
-    encode_test.go
-)
-
 END()
-
-RECURSE(gotest)