types: consistently name generated protos
Rename each generated protobuf package such that the base of the
Go package path is always equal to the Go package name to follow
proper Go package naming conventions.
The Go package name is derived from the .proto source file name by
replacing ".proto" with "pb" and stripping all underscores.
Change-Id: Iea05d1b5d94b1b2821ae10276ab771bb2df93c0e
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/177380
Reviewed-by: Damien Neil <dneil@google.com>
diff --git a/encoding/protojson/bench_test.go b/encoding/protojson/bench_test.go
index 70603af..8d5a0bb 100644
--- a/encoding/protojson/bench_test.go
+++ b/encoding/protojson/bench_test.go
@@ -8,14 +8,15 @@
"testing"
"google.golang.org/protobuf/encoding/protojson"
- knownpb "google.golang.org/protobuf/types/known"
+
+ "google.golang.org/protobuf/types/known/durationpb"
)
func BenchmarkUnmarshal_Duration(b *testing.B) {
input := []byte(`"-123456789.123456789s"`)
for i := 0; i < b.N; i++ {
- err := protojson.Unmarshal(input, &knownpb.Duration{})
+ err := protojson.Unmarshal(input, &durationpb.Duration{})
if err != nil {
b.Fatal(err)
}
diff --git a/encoding/protojson/decode_test.go b/encoding/protojson/decode_test.go
index ba8f10b..b713a38 100644
--- a/encoding/protojson/decode_test.go
+++ b/encoding/protojson/decode_test.go
@@ -19,7 +19,13 @@
preg "google.golang.org/protobuf/reflect/protoregistry"
"google.golang.org/protobuf/runtime/protoiface"
- knownpb "google.golang.org/protobuf/types/known"
+ "google.golang.org/protobuf/types/known/anypb"
+ "google.golang.org/protobuf/types/known/durationpb"
+ "google.golang.org/protobuf/types/known/emptypb"
+ "google.golang.org/protobuf/types/known/fieldmaskpb"
+ "google.golang.org/protobuf/types/known/structpb"
+ "google.golang.org/protobuf/types/known/timestamppb"
+ "google.golang.org/protobuf/types/known/wrapperspb"
)
func init() {
@@ -1429,101 +1435,101 @@
}(),
}, {
desc: "Empty",
- inputMessage: &knownpb.Empty{},
+ inputMessage: &emptypb.Empty{},
inputText: `{}`,
- wantMessage: &knownpb.Empty{},
+ wantMessage: &emptypb.Empty{},
}, {
desc: "Empty contains unknown",
- inputMessage: &knownpb.Empty{},
+ inputMessage: &emptypb.Empty{},
inputText: `{"unknown": null}`,
wantErr: true,
}, {
desc: "BoolValue false",
- inputMessage: &knownpb.BoolValue{},
+ inputMessage: &wrapperspb.BoolValue{},
inputText: `false`,
- wantMessage: &knownpb.BoolValue{},
+ wantMessage: &wrapperspb.BoolValue{},
}, {
desc: "BoolValue true",
- inputMessage: &knownpb.BoolValue{},
+ inputMessage: &wrapperspb.BoolValue{},
inputText: `true`,
- wantMessage: &knownpb.BoolValue{Value: true},
+ wantMessage: &wrapperspb.BoolValue{Value: true},
}, {
desc: "BoolValue invalid value",
- inputMessage: &knownpb.BoolValue{},
+ inputMessage: &wrapperspb.BoolValue{},
inputText: `{}`,
wantErr: true,
}, {
desc: "Int32Value",
- inputMessage: &knownpb.Int32Value{},
+ inputMessage: &wrapperspb.Int32Value{},
inputText: `42`,
- wantMessage: &knownpb.Int32Value{Value: 42},
+ wantMessage: &wrapperspb.Int32Value{Value: 42},
}, {
desc: "Int32Value in JSON string",
- inputMessage: &knownpb.Int32Value{},
+ inputMessage: &wrapperspb.Int32Value{},
inputText: `"1.23e3"`,
- wantMessage: &knownpb.Int32Value{Value: 1230},
+ wantMessage: &wrapperspb.Int32Value{Value: 1230},
}, {
desc: "Int64Value",
- inputMessage: &knownpb.Int64Value{},
+ inputMessage: &wrapperspb.Int64Value{},
inputText: `"42"`,
- wantMessage: &knownpb.Int64Value{Value: 42},
+ wantMessage: &wrapperspb.Int64Value{Value: 42},
}, {
desc: "UInt32Value",
- inputMessage: &knownpb.UInt32Value{},
+ inputMessage: &wrapperspb.UInt32Value{},
inputText: `42`,
- wantMessage: &knownpb.UInt32Value{Value: 42},
+ wantMessage: &wrapperspb.UInt32Value{Value: 42},
}, {
desc: "UInt64Value",
- inputMessage: &knownpb.UInt64Value{},
+ inputMessage: &wrapperspb.UInt64Value{},
inputText: `"42"`,
- wantMessage: &knownpb.UInt64Value{Value: 42},
+ wantMessage: &wrapperspb.UInt64Value{Value: 42},
}, {
desc: "FloatValue",
- inputMessage: &knownpb.FloatValue{},
+ inputMessage: &wrapperspb.FloatValue{},
inputText: `1.02`,
- wantMessage: &knownpb.FloatValue{Value: 1.02},
+ wantMessage: &wrapperspb.FloatValue{Value: 1.02},
}, {
desc: "FloatValue exceeds max limit",
- inputMessage: &knownpb.FloatValue{},
+ inputMessage: &wrapperspb.FloatValue{},
inputText: `1.23+40`,
wantErr: true,
}, {
desc: "FloatValue Infinity",
- inputMessage: &knownpb.FloatValue{},
+ inputMessage: &wrapperspb.FloatValue{},
inputText: `"-Infinity"`,
- wantMessage: &knownpb.FloatValue{Value: float32(math.Inf(-1))},
+ wantMessage: &wrapperspb.FloatValue{Value: float32(math.Inf(-1))},
}, {
desc: "DoubleValue",
- inputMessage: &knownpb.DoubleValue{},
+ inputMessage: &wrapperspb.DoubleValue{},
inputText: `1.02`,
- wantMessage: &knownpb.DoubleValue{Value: 1.02},
+ wantMessage: &wrapperspb.DoubleValue{Value: 1.02},
}, {
desc: "DoubleValue Infinity",
- inputMessage: &knownpb.DoubleValue{},
+ inputMessage: &wrapperspb.DoubleValue{},
inputText: `"Infinity"`,
- wantMessage: &knownpb.DoubleValue{Value: math.Inf(+1)},
+ wantMessage: &wrapperspb.DoubleValue{Value: math.Inf(+1)},
}, {
desc: "StringValue empty",
- inputMessage: &knownpb.StringValue{},
+ inputMessage: &wrapperspb.StringValue{},
inputText: `""`,
- wantMessage: &knownpb.StringValue{},
+ wantMessage: &wrapperspb.StringValue{},
}, {
desc: "StringValue",
- inputMessage: &knownpb.StringValue{},
+ inputMessage: &wrapperspb.StringValue{},
inputText: `"谷歌"`,
- wantMessage: &knownpb.StringValue{Value: "谷歌"},
+ wantMessage: &wrapperspb.StringValue{Value: "谷歌"},
}, {
desc: "StringValue with invalid UTF8 error",
- inputMessage: &knownpb.StringValue{},
+ inputMessage: &wrapperspb.StringValue{},
inputText: "\"abc\xff\"",
- wantMessage: &knownpb.StringValue{Value: "abc\xff"},
+ wantMessage: &wrapperspb.StringValue{Value: "abc\xff"},
wantErr: true,
}, {
desc: "StringValue field with invalid UTF8 error",
inputMessage: &pb2.KnownTypes{},
inputText: "{\n \"optString\": \"abc\xff\"\n}",
wantMessage: &pb2.KnownTypes{
- OptString: &knownpb.StringValue{Value: "abc\xff"},
+ OptString: &wrapperspb.StringValue{Value: "abc\xff"},
},
wantErr: true,
}, {
@@ -1532,24 +1538,24 @@
inputText: `{
"optNull": null
}`,
- wantMessage: &pb2.KnownTypes{OptNull: new(knownpb.NullValue)},
+ wantMessage: &pb2.KnownTypes{OptNull: new(structpb.NullValue)},
}, {
desc: "NullValue field with string",
inputMessage: &pb2.KnownTypes{},
inputText: `{
"optNull": "NULL_VALUE"
}`,
- wantMessage: &pb2.KnownTypes{OptNull: new(knownpb.NullValue)},
+ wantMessage: &pb2.KnownTypes{OptNull: new(structpb.NullValue)},
}, {
desc: "BytesValue",
- inputMessage: &knownpb.BytesValue{},
+ inputMessage: &wrapperspb.BytesValue{},
inputText: `"aGVsbG8="`,
- wantMessage: &knownpb.BytesValue{Value: []byte("hello")},
+ wantMessage: &wrapperspb.BytesValue{Value: []byte("hello")},
}, {
desc: "Value null",
- inputMessage: &knownpb.Value{},
+ inputMessage: &structpb.Value{},
inputText: `null`,
- wantMessage: &knownpb.Value{Kind: &knownpb.Value_NullValue{}},
+ wantMessage: &structpb.Value{Kind: &structpb.Value_NullValue{}},
}, {
desc: "Value field null",
inputMessage: &pb2.KnownTypes{},
@@ -1557,13 +1563,13 @@
"optValue": null
}`,
wantMessage: &pb2.KnownTypes{
- OptValue: &knownpb.Value{Kind: &knownpb.Value_NullValue{}},
+ OptValue: &structpb.Value{Kind: &structpb.Value_NullValue{}},
},
}, {
desc: "Value bool",
- inputMessage: &knownpb.Value{},
+ inputMessage: &structpb.Value{},
inputText: `false`,
- wantMessage: &knownpb.Value{Kind: &knownpb.Value_BoolValue{}},
+ wantMessage: &structpb.Value{Kind: &structpb.Value_BoolValue{}},
}, {
desc: "Value field bool",
inputMessage: &pb2.KnownTypes{},
@@ -1571,13 +1577,13 @@
"optValue": true
}`,
wantMessage: &pb2.KnownTypes{
- OptValue: &knownpb.Value{Kind: &knownpb.Value_BoolValue{true}},
+ OptValue: &structpb.Value{Kind: &structpb.Value_BoolValue{true}},
},
}, {
desc: "Value number",
- inputMessage: &knownpb.Value{},
+ inputMessage: &structpb.Value{},
inputText: `1.02`,
- wantMessage: &knownpb.Value{Kind: &knownpb.Value_NumberValue{1.02}},
+ wantMessage: &structpb.Value{Kind: &structpb.Value_NumberValue{1.02}},
}, {
desc: "Value field number",
inputMessage: &pb2.KnownTypes{},
@@ -1585,18 +1591,18 @@
"optValue": 1.02
}`,
wantMessage: &pb2.KnownTypes{
- OptValue: &knownpb.Value{Kind: &knownpb.Value_NumberValue{1.02}},
+ OptValue: &structpb.Value{Kind: &structpb.Value_NumberValue{1.02}},
},
}, {
desc: "Value string",
- inputMessage: &knownpb.Value{},
+ inputMessage: &structpb.Value{},
inputText: `"hello"`,
- wantMessage: &knownpb.Value{Kind: &knownpb.Value_StringValue{"hello"}},
+ wantMessage: &structpb.Value{Kind: &structpb.Value_StringValue{"hello"}},
}, {
desc: "Value string with invalid UTF8",
- inputMessage: &knownpb.Value{},
+ inputMessage: &structpb.Value{},
inputText: "\"\xff\"",
- wantMessage: &knownpb.Value{Kind: &knownpb.Value_StringValue{"\xff"}},
+ wantMessage: &structpb.Value{Kind: &structpb.Value_StringValue{"\xff"}},
wantErr: true,
}, {
desc: "Value field string",
@@ -1605,7 +1611,7 @@
"optValue": "NaN"
}`,
wantMessage: &pb2.KnownTypes{
- OptValue: &knownpb.Value{Kind: &knownpb.Value_StringValue{"NaN"}},
+ OptValue: &structpb.Value{Kind: &structpb.Value_StringValue{"NaN"}},
},
}, {
desc: "Value field string with invalid UTF8",
@@ -1614,21 +1620,21 @@
"optValue": "` + "\xff" + `"
}`,
wantMessage: &pb2.KnownTypes{
- OptValue: &knownpb.Value{Kind: &knownpb.Value_StringValue{"\xff"}},
+ OptValue: &structpb.Value{Kind: &structpb.Value_StringValue{"\xff"}},
},
wantErr: true,
}, {
desc: "Value empty struct",
- inputMessage: &knownpb.Value{},
+ inputMessage: &structpb.Value{},
inputText: `{}`,
- wantMessage: &knownpb.Value{
- Kind: &knownpb.Value_StructValue{
- &knownpb.Struct{Fields: map[string]*knownpb.Value{}},
+ wantMessage: &structpb.Value{
+ Kind: &structpb.Value_StructValue{
+ &structpb.Struct{Fields: map[string]*structpb.Value{}},
},
},
}, {
desc: "Value struct",
- inputMessage: &knownpb.Value{},
+ inputMessage: &structpb.Value{},
inputText: `{
"string": "hello",
"number": 123,
@@ -1639,25 +1645,25 @@
},
"list": []
}`,
- wantMessage: &knownpb.Value{
- Kind: &knownpb.Value_StructValue{
- &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "string": {Kind: &knownpb.Value_StringValue{"hello"}},
- "number": {Kind: &knownpb.Value_NumberValue{123}},
- "null": {Kind: &knownpb.Value_NullValue{}},
- "bool": {Kind: &knownpb.Value_BoolValue{false}},
+ wantMessage: &structpb.Value{
+ Kind: &structpb.Value_StructValue{
+ &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "string": {Kind: &structpb.Value_StringValue{"hello"}},
+ "number": {Kind: &structpb.Value_NumberValue{123}},
+ "null": {Kind: &structpb.Value_NullValue{}},
+ "bool": {Kind: &structpb.Value_BoolValue{false}},
"struct": {
- Kind: &knownpb.Value_StructValue{
- &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "string": {Kind: &knownpb.Value_StringValue{"world"}},
+ Kind: &structpb.Value_StructValue{
+ &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "string": {Kind: &structpb.Value_StringValue{"world"}},
},
},
},
},
"list": {
- Kind: &knownpb.Value_ListValue{&knownpb.ListValue{}},
+ Kind: &structpb.Value_ListValue{&structpb.ListValue{}},
},
},
},
@@ -1665,13 +1671,13 @@
},
}, {
desc: "Value struct with invalid UTF8 string",
- inputMessage: &knownpb.Value{},
+ inputMessage: &structpb.Value{},
inputText: "{\"string\": \"abc\xff\"}",
- wantMessage: &knownpb.Value{
- Kind: &knownpb.Value_StructValue{
- &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "string": {Kind: &knownpb.Value_StringValue{"abc\xff"}},
+ wantMessage: &structpb.Value{
+ Kind: &structpb.Value_StructValue{
+ &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "string": {Kind: &structpb.Value_StringValue{"abc\xff"}},
},
},
},
@@ -1686,11 +1692,11 @@
}
}`,
wantMessage: &pb2.KnownTypes{
- OptValue: &knownpb.Value{
- Kind: &knownpb.Value_StructValue{
- &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "string": {Kind: &knownpb.Value_StringValue{"hello"}},
+ OptValue: &structpb.Value{
+ Kind: &structpb.Value_StructValue{
+ &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "string": {Kind: &structpb.Value_StringValue{"hello"}},
},
},
},
@@ -1698,16 +1704,16 @@
},
}, {
desc: "Value empty list",
- inputMessage: &knownpb.Value{},
+ inputMessage: &structpb.Value{},
inputText: `[]`,
- wantMessage: &knownpb.Value{
- Kind: &knownpb.Value_ListValue{
- &knownpb.ListValue{Values: []*knownpb.Value{}},
+ wantMessage: &structpb.Value{
+ Kind: &structpb.Value_ListValue{
+ &structpb.ListValue{Values: []*structpb.Value{}},
},
},
}, {
desc: "Value list",
- inputMessage: &knownpb.Value{},
+ inputMessage: &structpb.Value{},
inputText: `[
"string",
123,
@@ -1721,23 +1727,23 @@
false
]
]`,
- wantMessage: &knownpb.Value{
- Kind: &knownpb.Value_ListValue{
- &knownpb.ListValue{
- Values: []*knownpb.Value{
- {Kind: &knownpb.Value_StringValue{"string"}},
- {Kind: &knownpb.Value_NumberValue{123}},
- {Kind: &knownpb.Value_NullValue{}},
- {Kind: &knownpb.Value_BoolValue{true}},
- {Kind: &knownpb.Value_StructValue{&knownpb.Struct{}}},
+ wantMessage: &structpb.Value{
+ Kind: &structpb.Value_ListValue{
+ &structpb.ListValue{
+ Values: []*structpb.Value{
+ {Kind: &structpb.Value_StringValue{"string"}},
+ {Kind: &structpb.Value_NumberValue{123}},
+ {Kind: &structpb.Value_NullValue{}},
+ {Kind: &structpb.Value_BoolValue{true}},
+ {Kind: &structpb.Value_StructValue{&structpb.Struct{}}},
{
- Kind: &knownpb.Value_ListValue{
- &knownpb.ListValue{
- Values: []*knownpb.Value{
- {Kind: &knownpb.Value_StringValue{"string"}},
- {Kind: &knownpb.Value_NumberValue{1.23}},
- {Kind: &knownpb.Value_NullValue{}},
- {Kind: &knownpb.Value_BoolValue{false}},
+ Kind: &structpb.Value_ListValue{
+ &structpb.ListValue{
+ Values: []*structpb.Value{
+ {Kind: &structpb.Value_StringValue{"string"}},
+ {Kind: &structpb.Value_NumberValue{1.23}},
+ {Kind: &structpb.Value_NullValue{}},
+ {Kind: &structpb.Value_BoolValue{false}},
},
},
},
@@ -1748,13 +1754,13 @@
},
}, {
desc: "Value list with invalid UTF8 string",
- inputMessage: &knownpb.Value{},
+ inputMessage: &structpb.Value{},
inputText: "[\"abc\xff\"]",
- wantMessage: &knownpb.Value{
- Kind: &knownpb.Value_ListValue{
- &knownpb.ListValue{
- Values: []*knownpb.Value{
- {Kind: &knownpb.Value_StringValue{"abc\xff"}},
+ wantMessage: &structpb.Value{
+ Kind: &structpb.Value_ListValue{
+ &structpb.ListValue{
+ Values: []*structpb.Value{
+ {Kind: &structpb.Value_StringValue{"abc\xff"}},
},
},
},
@@ -1767,11 +1773,11 @@
"optValue": [ "` + "abc\xff" + `"]
}`,
wantMessage: &pb2.KnownTypes{
- OptValue: &knownpb.Value{
- Kind: &knownpb.Value_ListValue{
- &knownpb.ListValue{
- Values: []*knownpb.Value{
- {Kind: &knownpb.Value_StringValue{"abc\xff"}},
+ OptValue: &structpb.Value{
+ Kind: &structpb.Value_ListValue{
+ &structpb.ListValue{
+ Values: []*structpb.Value{
+ {Kind: &structpb.Value_StringValue{"abc\xff"}},
},
},
},
@@ -1780,174 +1786,174 @@
wantErr: true,
}, {
desc: "Duration empty string",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `""`,
wantErr: true,
}, {
desc: "Duration with secs",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"3s"`,
- wantMessage: &knownpb.Duration{Seconds: 3},
+ wantMessage: &durationpb.Duration{Seconds: 3},
}, {
desc: "Duration with escaped unicode",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"\u0033s"`,
- wantMessage: &knownpb.Duration{Seconds: 3},
+ wantMessage: &durationpb.Duration{Seconds: 3},
}, {
desc: "Duration with -secs",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"-3s"`,
- wantMessage: &knownpb.Duration{Seconds: -3},
+ wantMessage: &durationpb.Duration{Seconds: -3},
}, {
desc: "Duration with plus sign",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"+3s"`,
- wantMessage: &knownpb.Duration{Seconds: 3},
+ wantMessage: &durationpb.Duration{Seconds: 3},
}, {
desc: "Duration with nanos",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"0.001s"`,
- wantMessage: &knownpb.Duration{Nanos: 1e6},
+ wantMessage: &durationpb.Duration{Nanos: 1e6},
}, {
desc: "Duration with -nanos",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"-0.001s"`,
- wantMessage: &knownpb.Duration{Nanos: -1e6},
+ wantMessage: &durationpb.Duration{Nanos: -1e6},
}, {
desc: "Duration with -nanos",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"-.001s"`,
- wantMessage: &knownpb.Duration{Nanos: -1e6},
+ wantMessage: &durationpb.Duration{Nanos: -1e6},
}, {
desc: "Duration with +nanos",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"+.001s"`,
- wantMessage: &knownpb.Duration{Nanos: 1e6},
+ wantMessage: &durationpb.Duration{Nanos: 1e6},
}, {
desc: "Duration with -secs -nanos",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"-123.000000450s"`,
- wantMessage: &knownpb.Duration{Seconds: -123, Nanos: -450},
+ wantMessage: &durationpb.Duration{Seconds: -123, Nanos: -450},
}, {
desc: "Duration with large secs",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"10000000000.000000001s"`,
- wantMessage: &knownpb.Duration{Seconds: 1e10, Nanos: 1},
+ wantMessage: &durationpb.Duration{Seconds: 1e10, Nanos: 1},
}, {
desc: "Duration with decimal without fractional",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"3.s"`,
- wantMessage: &knownpb.Duration{Seconds: 3},
+ wantMessage: &durationpb.Duration{Seconds: 3},
}, {
desc: "Duration with decimal without integer",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"0.5s"`,
- wantMessage: &knownpb.Duration{Nanos: 5e8},
+ wantMessage: &durationpb.Duration{Nanos: 5e8},
}, {
desc: "Duration max value",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"315576000000.999999999s"`,
- wantMessage: &knownpb.Duration{Seconds: 315576000000, Nanos: 999999999},
+ wantMessage: &durationpb.Duration{Seconds: 315576000000, Nanos: 999999999},
}, {
desc: "Duration min value",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"-315576000000.999999999s"`,
- wantMessage: &knownpb.Duration{Seconds: -315576000000, Nanos: -999999999},
+ wantMessage: &durationpb.Duration{Seconds: -315576000000, Nanos: -999999999},
}, {
desc: "Duration with +secs out of range",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"315576000001s"`,
wantErr: true,
}, {
desc: "Duration with -secs out of range",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"-315576000001s"`,
wantErr: true,
}, {
desc: "Duration with nanos beyond 9 digits",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"0.1000000000s"`,
wantErr: true,
}, {
desc: "Duration without suffix s",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"123"`,
wantErr: true,
}, {
desc: "Duration invalid signed fraction",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"123.+123s"`,
wantErr: true,
}, {
desc: "Duration invalid multiple .",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"123.123.s"`,
wantErr: true,
}, {
desc: "Duration invalid integer",
- inputMessage: &knownpb.Duration{},
+ inputMessage: &durationpb.Duration{},
inputText: `"01s"`,
wantErr: true,
}, {
desc: "Timestamp zero",
- inputMessage: &knownpb.Timestamp{},
+ inputMessage: ×tamppb.Timestamp{},
inputText: `"1970-01-01T00:00:00Z"`,
- wantMessage: &knownpb.Timestamp{},
+ wantMessage: ×tamppb.Timestamp{},
}, {
desc: "Timestamp with tz adjustment",
- inputMessage: &knownpb.Timestamp{},
+ inputMessage: ×tamppb.Timestamp{},
inputText: `"1970-01-01T00:00:00+01:00"`,
- wantMessage: &knownpb.Timestamp{Seconds: -3600},
+ wantMessage: ×tamppb.Timestamp{Seconds: -3600},
}, {
desc: "Timestamp UTC",
- inputMessage: &knownpb.Timestamp{},
+ inputMessage: ×tamppb.Timestamp{},
inputText: `"2019-03-19T23:03:21Z"`,
- wantMessage: &knownpb.Timestamp{Seconds: 1553036601},
+ wantMessage: ×tamppb.Timestamp{Seconds: 1553036601},
}, {
desc: "Timestamp with escaped unicode",
- inputMessage: &knownpb.Timestamp{},
+ inputMessage: ×tamppb.Timestamp{},
inputText: `"2019-0\u0033-19T23:03:21Z"`,
- wantMessage: &knownpb.Timestamp{Seconds: 1553036601},
+ wantMessage: ×tamppb.Timestamp{Seconds: 1553036601},
}, {
desc: "Timestamp with nanos",
- inputMessage: &knownpb.Timestamp{},
+ inputMessage: ×tamppb.Timestamp{},
inputText: `"2019-03-19T23:03:21.000000001Z"`,
- wantMessage: &knownpb.Timestamp{Seconds: 1553036601, Nanos: 1},
+ wantMessage: ×tamppb.Timestamp{Seconds: 1553036601, Nanos: 1},
}, {
desc: "Timestamp max value",
- inputMessage: &knownpb.Timestamp{},
+ inputMessage: ×tamppb.Timestamp{},
inputText: `"9999-12-31T23:59:59.999999999Z"`,
- wantMessage: &knownpb.Timestamp{Seconds: 253402300799, Nanos: 999999999},
+ wantMessage: ×tamppb.Timestamp{Seconds: 253402300799, Nanos: 999999999},
}, {
desc: "Timestamp above max value",
- inputMessage: &knownpb.Timestamp{},
+ inputMessage: ×tamppb.Timestamp{},
inputText: `"9999-12-31T23:59:59-01:00"`,
wantErr: true,
}, {
desc: "Timestamp min value",
- inputMessage: &knownpb.Timestamp{},
+ inputMessage: ×tamppb.Timestamp{},
inputText: `"0001-01-01T00:00:00Z"`,
- wantMessage: &knownpb.Timestamp{Seconds: -62135596800},
+ wantMessage: ×tamppb.Timestamp{Seconds: -62135596800},
}, {
desc: "Timestamp below min value",
- inputMessage: &knownpb.Timestamp{},
+ inputMessage: ×tamppb.Timestamp{},
inputText: `"0001-01-01T00:00:00+01:00"`,
wantErr: true,
}, {
desc: "Timestamp with nanos beyond 9 digits",
- inputMessage: &knownpb.Timestamp{},
+ inputMessage: ×tamppb.Timestamp{},
inputText: `"1970-01-01T00:00:00.0000000001Z"`,
wantErr: true,
}, {
desc: "FieldMask empty",
- inputMessage: &knownpb.FieldMask{},
+ inputMessage: &fieldmaskpb.FieldMask{},
inputText: `""`,
- wantMessage: &knownpb.FieldMask{Paths: []string{}},
+ wantMessage: &fieldmaskpb.FieldMask{Paths: []string{}},
}, {
desc: "FieldMask",
- inputMessage: &knownpb.FieldMask{},
+ inputMessage: &fieldmaskpb.FieldMask{},
inputText: `"foo,fooBar , foo.barQux ,Foo"`,
- wantMessage: &knownpb.FieldMask{
+ wantMessage: &fieldmaskpb.FieldMask{
Paths: []string{
"foo",
"foo_bar",
@@ -1962,7 +1968,7 @@
"optFieldmask": "foo, qux.fooBar"
}`,
wantMessage: &pb2.KnownTypes{
- OptFieldmask: &knownpb.FieldMask{
+ OptFieldmask: &fieldmaskpb.FieldMask{
Paths: []string{
"foo",
"qux.foo_bar",
@@ -1971,15 +1977,15 @@
},
}, {
desc: "Any empty",
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{}`,
- wantMessage: &knownpb.Any{},
+ wantMessage: &anypb.Any{},
}, {
desc: "Any with non-custom message",
umo: protojson.UnmarshalOptions{
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "foo/pb2.Nested",
"optString": "embedded inside Any",
@@ -1998,7 +2004,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "foo/pb2.Nested",
Value: b,
}
@@ -2008,13 +2014,13 @@
umo: protojson.UnmarshalOptions{
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{"@type": "foo/pb2.Nested"}`,
- wantMessage: &knownpb.Any{TypeUrl: "foo/pb2.Nested"},
+ wantMessage: &anypb.Any{TypeUrl: "foo/pb2.Nested"},
}, {
desc: "Any without registered type",
umo: protojson.UnmarshalOptions{Resolver: preg.NewTypes()},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{"@type": "foo/pb2.Nested"}`,
wantErr: true,
}, {
@@ -2022,7 +2028,7 @@
umo: protojson.UnmarshalOptions{
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.PartialRequired{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "pb2.PartialRequired",
"optString": "embedded inside Any"
@@ -2038,7 +2044,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: string(m.ProtoReflect().Descriptor().FullName()),
Value: b,
}
@@ -2050,7 +2056,7 @@
AllowPartial: true,
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.PartialRequired{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "pb2.PartialRequired",
"optString": "embedded inside Any"
@@ -2066,7 +2072,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: string(m.ProtoReflect().Descriptor().FullName()),
Value: b,
}
@@ -2076,7 +2082,7 @@
umo: protojson.UnmarshalOptions{
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"optString": "` + "abc\xff" + `",
"@type": "foo/pb2.Nested"
@@ -2089,7 +2095,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "foo/pb2.Nested",
Value: b,
}
@@ -2098,20 +2104,20 @@
}, {
desc: "Any with BoolValue",
umo: protojson.UnmarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.BoolValue{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&wrapperspb.BoolValue{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "type.googleapis.com/google.protobuf.BoolValue",
"value": true
}`,
wantMessage: func() proto.Message {
- m := &knownpb.BoolValue{Value: true}
+ m := &wrapperspb.BoolValue{Value: true}
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "type.googleapis.com/google.protobuf.BoolValue",
Value: b,
}
@@ -2119,22 +2125,22 @@
}, {
desc: "Any with Empty",
umo: protojson.UnmarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.Empty{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&emptypb.Empty{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"value": {},
"@type": "type.googleapis.com/google.protobuf.Empty"
}`,
- wantMessage: &knownpb.Any{
+ wantMessage: &anypb.Any{
TypeUrl: "type.googleapis.com/google.protobuf.Empty",
},
}, {
desc: "Any with missing Empty",
umo: protojson.UnmarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.Empty{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&emptypb.Empty{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "type.googleapis.com/google.protobuf.Empty"
}`,
@@ -2142,20 +2148,20 @@
}, {
desc: "Any with StringValue containing invalid UTF8",
umo: protojson.UnmarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.StringValue{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&wrapperspb.StringValue{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "google.protobuf.StringValue",
"value": "` + "abc\xff" + `"
}`,
wantMessage: func() proto.Message {
- m := &knownpb.StringValue{Value: "abcd"}
+ m := &wrapperspb.StringValue{Value: "abcd"}
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "google.protobuf.StringValue",
Value: bytes.Replace(b, []byte("abcd"), []byte("abc\xff"), -1),
}
@@ -2164,20 +2170,20 @@
}, {
desc: "Any with Int64Value",
umo: protojson.UnmarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.Int64Value{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&wrapperspb.Int64Value{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "google.protobuf.Int64Value",
"value": "42"
}`,
wantMessage: func() proto.Message {
- m := &knownpb.Int64Value{Value: 42}
+ m := &wrapperspb.Int64Value{Value: 42}
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "google.protobuf.Int64Value",
Value: b,
}
@@ -2185,9 +2191,9 @@
}, {
desc: "Any with invalid Int64Value",
umo: protojson.UnmarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.Int64Value{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&wrapperspb.Int64Value{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "google.protobuf.Int64Value",
"value": "forty-two"
@@ -2196,9 +2202,9 @@
}, {
desc: "Any with invalid UInt64Value",
umo: protojson.UnmarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.UInt64Value{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&wrapperspb.UInt64Value{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "google.protobuf.UInt64Value",
"value": -42
@@ -2207,20 +2213,20 @@
}, {
desc: "Any with Duration",
umo: protojson.UnmarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.Duration{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&durationpb.Duration{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "type.googleapis.com/google.protobuf.Duration",
"value": "0s"
}`,
wantMessage: func() proto.Message {
- m := &knownpb.Duration{}
+ m := &durationpb.Duration{}
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "type.googleapis.com/google.protobuf.Duration",
Value: b,
}
@@ -2228,20 +2234,20 @@
}, {
desc: "Any with Value of StringValue",
umo: protojson.UnmarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.Value{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&structpb.Value{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "google.protobuf.Value",
"value": "` + "abc\xff" + `"
}`,
wantMessage: func() proto.Message {
- m := &knownpb.Value{Kind: &knownpb.Value_StringValue{"abcd"}}
+ m := &structpb.Value{Kind: &structpb.Value_StringValue{"abcd"}}
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "google.protobuf.Value",
Value: bytes.Replace(b, []byte("abcd"), []byte("abc\xff"), -1),
}
@@ -2250,20 +2256,20 @@
}, {
desc: "Any with Value of NullValue",
umo: protojson.UnmarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.Value{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&structpb.Value{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "google.protobuf.Value",
"value": null
}`,
wantMessage: func() proto.Message {
- m := &knownpb.Value{Kind: &knownpb.Value_NullValue{}}
+ m := &structpb.Value{Kind: &structpb.Value_NullValue{}}
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "google.protobuf.Value",
Value: b,
}
@@ -2272,14 +2278,14 @@
desc: "Any with Struct",
umo: protojson.UnmarshalOptions{
Resolver: preg.NewTypes(
- pimpl.Export{}.MessageTypeOf(&knownpb.Struct{}),
- pimpl.Export{}.MessageTypeOf(&knownpb.Value{}),
- pimpl.Export{}.MessageTypeOf(&knownpb.BoolValue{}),
- pimpl.Export{}.EnumTypeOf(knownpb.NullValue_NULL_VALUE),
- pimpl.Export{}.MessageTypeOf(&knownpb.StringValue{}),
+ pimpl.Export{}.MessageTypeOf(&structpb.Struct{}),
+ pimpl.Export{}.MessageTypeOf(&structpb.Value{}),
+ pimpl.Export{}.MessageTypeOf(&wrapperspb.BoolValue{}),
+ pimpl.Export{}.EnumTypeOf(structpb.NullValue_NULL_VALUE),
+ pimpl.Export{}.MessageTypeOf(&wrapperspb.StringValue{}),
),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "google.protobuf.Struct",
"value": {
@@ -2292,16 +2298,16 @@
}
}`,
wantMessage: func() proto.Message {
- m := &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "bool": {Kind: &knownpb.Value_BoolValue{true}},
- "null": {Kind: &knownpb.Value_NullValue{}},
- "string": {Kind: &knownpb.Value_StringValue{"hello"}},
+ m := &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "bool": {Kind: &structpb.Value_BoolValue{true}},
+ "null": {Kind: &structpb.Value_NullValue{}},
+ "string": {Kind: &structpb.Value_StringValue{"hello"}},
"struct": {
- Kind: &knownpb.Value_StructValue{
- &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "string": {Kind: &knownpb.Value_StringValue{"world"}},
+ Kind: &structpb.Value_StructValue{
+ &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "string": {Kind: &structpb.Value_StringValue{"world"}},
},
},
},
@@ -2312,7 +2318,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "google.protobuf.Struct",
Value: b,
}
@@ -2320,14 +2326,14 @@
}, {
desc: "Any with missing @type",
umo: protojson.UnmarshalOptions{},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"value": {}
}`,
wantErr: true,
}, {
desc: "Any with empty @type",
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": ""
}`,
@@ -2337,10 +2343,10 @@
umo: protojson.UnmarshalOptions{
Resolver: preg.NewTypes(
pimpl.Export{}.MessageTypeOf(&pb2.Nested{}),
- pimpl.Export{}.MessageTypeOf(&knownpb.StringValue{}),
+ pimpl.Export{}.MessageTypeOf(&wrapperspb.StringValue{}),
),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "google.protobuf.StringValue",
"value": "hello",
@@ -2350,9 +2356,9 @@
}, {
desc: "Any with duplicate value",
umo: protojson.UnmarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.StringValue{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&wrapperspb.StringValue{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "google.protobuf.StringValue",
"value": "hello",
@@ -2364,7 +2370,7 @@
umo: protojson.UnmarshalOptions{
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "pb2.Nested",
"optString": "hello",
@@ -2376,11 +2382,11 @@
umo: protojson.UnmarshalOptions{
Resolver: preg.NewTypes(
pimpl.Export{}.MessageTypeOf(&pb2.KnownTypes{}),
- pimpl.Export{}.MessageTypeOf(&knownpb.Any{}),
- pimpl.Export{}.MessageTypeOf(&knownpb.StringValue{}),
+ pimpl.Export{}.MessageTypeOf(&anypb.Any{}),
+ pimpl.Export{}.MessageTypeOf(&wrapperspb.StringValue{}),
),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "pb2.KnownTypes",
"optAny": {
@@ -2389,12 +2395,12 @@
}
}`,
wantMessage: func() proto.Message {
- m1 := &knownpb.StringValue{Value: "abcd"}
+ m1 := &wrapperspb.StringValue{Value: "abcd"}
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m1)
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- m2 := &knownpb.Any{
+ m2 := &anypb.Any{
TypeUrl: "google.protobuf.StringValue",
Value: b,
}
@@ -2403,7 +2409,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "pb2.KnownTypes",
Value: bytes.Replace(b, []byte("abcd"), []byte("abc\xff"), -1),
}
@@ -2412,7 +2418,7 @@
}, {
desc: "well known types as field values",
umo: protojson.UnmarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.Empty{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&emptypb.Empty{})),
},
inputMessage: &pb2.KnownTypes{},
inputText: `{
@@ -2445,46 +2451,46 @@
"optFieldmask": "fooBar,barFoo"
}`,
wantMessage: &pb2.KnownTypes{
- OptBool: &knownpb.BoolValue{Value: false},
- OptInt32: &knownpb.Int32Value{Value: 42},
- OptInt64: &knownpb.Int64Value{Value: 42},
- OptUint32: &knownpb.UInt32Value{Value: 42},
- OptUint64: &knownpb.UInt64Value{Value: 42},
- OptFloat: &knownpb.FloatValue{Value: 1.23},
- OptDouble: &knownpb.DoubleValue{Value: 3.1415},
- OptString: &knownpb.StringValue{Value: "hello"},
- OptBytes: &knownpb.BytesValue{Value: []byte("hello")},
- OptDuration: &knownpb.Duration{Seconds: 123},
- OptTimestamp: &knownpb.Timestamp{Seconds: 1553036601},
- OptStruct: &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "string": {Kind: &knownpb.Value_StringValue{"hello"}},
+ OptBool: &wrapperspb.BoolValue{Value: false},
+ OptInt32: &wrapperspb.Int32Value{Value: 42},
+ OptInt64: &wrapperspb.Int64Value{Value: 42},
+ OptUint32: &wrapperspb.UInt32Value{Value: 42},
+ OptUint64: &wrapperspb.UInt64Value{Value: 42},
+ OptFloat: &wrapperspb.FloatValue{Value: 1.23},
+ OptDouble: &wrapperspb.DoubleValue{Value: 3.1415},
+ OptString: &wrapperspb.StringValue{Value: "hello"},
+ OptBytes: &wrapperspb.BytesValue{Value: []byte("hello")},
+ OptDuration: &durationpb.Duration{Seconds: 123},
+ OptTimestamp: ×tamppb.Timestamp{Seconds: 1553036601},
+ OptStruct: &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "string": {Kind: &structpb.Value_StringValue{"hello"}},
},
},
- OptList: &knownpb.ListValue{
- Values: []*knownpb.Value{
- {Kind: &knownpb.Value_NullValue{}},
- {Kind: &knownpb.Value_StringValue{}},
+ OptList: &structpb.ListValue{
+ Values: []*structpb.Value{
+ {Kind: &structpb.Value_NullValue{}},
+ {Kind: &structpb.Value_StringValue{}},
{
- Kind: &knownpb.Value_StructValue{
- &knownpb.Struct{Fields: map[string]*knownpb.Value{}},
+ Kind: &structpb.Value_StructValue{
+ &structpb.Struct{Fields: map[string]*structpb.Value{}},
},
},
{
- Kind: &knownpb.Value_ListValue{
- &knownpb.ListValue{Values: []*knownpb.Value{}},
+ Kind: &structpb.Value_ListValue{
+ &structpb.ListValue{Values: []*structpb.Value{}},
},
},
},
},
- OptValue: &knownpb.Value{
- Kind: &knownpb.Value_StringValue{"world"},
+ OptValue: &structpb.Value{
+ Kind: &structpb.Value_StringValue{"world"},
},
- OptEmpty: &knownpb.Empty{},
- OptAny: &knownpb.Any{
+ OptEmpty: &emptypb.Empty{},
+ OptAny: &anypb.Any{
TypeUrl: "google.protobuf.Empty",
},
- OptFieldmask: &knownpb.FieldMask{
+ OptFieldmask: &fieldmaskpb.FieldMask{
Paths: []string{"foo_bar", "bar_foo"},
},
},
@@ -2551,44 +2557,44 @@
}, {
desc: "DiscardUnknown: Empty",
umo: protojson.UnmarshalOptions{DiscardUnknown: true},
- inputMessage: &knownpb.Empty{},
+ inputMessage: &emptypb.Empty{},
inputText: `{"unknown": "something"}`,
- wantMessage: &knownpb.Empty{},
+ wantMessage: &emptypb.Empty{},
}, {
desc: "DiscardUnknown: Any without type",
umo: protojson.UnmarshalOptions{DiscardUnknown: true},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"value": {"foo": "bar"},
"unknown": true
}`,
- wantMessage: &knownpb.Any{},
+ wantMessage: &anypb.Any{},
}, {
desc: "DiscardUnknown: Any",
umo: protojson.UnmarshalOptions{
DiscardUnknown: true,
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "foo/pb2.Nested",
"unknown": "none"
}`,
- wantMessage: &knownpb.Any{
+ wantMessage: &anypb.Any{
TypeUrl: "foo/pb2.Nested",
},
}, {
desc: "DiscardUnknown: Any with Empty",
umo: protojson.UnmarshalOptions{
DiscardUnknown: true,
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.Empty{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&emptypb.Empty{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `{
"@type": "type.googleapis.com/google.protobuf.Empty",
"value": {"unknown": 47}
}`,
- wantMessage: &knownpb.Any{
+ wantMessage: &anypb.Any{
TypeUrl: "type.googleapis.com/google.protobuf.Empty",
},
}}
diff --git a/encoding/protojson/encode_test.go b/encoding/protojson/encode_test.go
index c652118..3483aed 100644
--- a/encoding/protojson/encode_test.go
+++ b/encoding/protojson/encode_test.go
@@ -24,7 +24,13 @@
"google.golang.org/protobuf/encoding/testprotos/pb2"
"google.golang.org/protobuf/encoding/testprotos/pb3"
- knownpb "google.golang.org/protobuf/types/known"
+ "google.golang.org/protobuf/types/known/anypb"
+ "google.golang.org/protobuf/types/known/durationpb"
+ "google.golang.org/protobuf/types/known/emptypb"
+ "google.golang.org/protobuf/types/known/fieldmaskpb"
+ "google.golang.org/protobuf/types/known/structpb"
+ "google.golang.org/protobuf/types/known/timestamppb"
+ "google.golang.org/protobuf/types/known/wrapperspb"
)
// splitLines is a cmpopts.Option for comparing strings with line breaks.
@@ -1105,125 +1111,125 @@
}`,
}, {
desc: "BoolValue empty",
- input: &knownpb.BoolValue{},
+ input: &wrapperspb.BoolValue{},
want: `false`,
}, {
desc: "BoolValue",
- input: &knownpb.BoolValue{Value: true},
+ input: &wrapperspb.BoolValue{Value: true},
want: `true`,
}, {
desc: "Int32Value empty",
- input: &knownpb.Int32Value{},
+ input: &wrapperspb.Int32Value{},
want: `0`,
}, {
desc: "Int32Value",
- input: &knownpb.Int32Value{Value: 42},
+ input: &wrapperspb.Int32Value{Value: 42},
want: `42`,
}, {
desc: "Int64Value",
- input: &knownpb.Int64Value{Value: 42},
+ input: &wrapperspb.Int64Value{Value: 42},
want: `"42"`,
}, {
desc: "UInt32Value",
- input: &knownpb.UInt32Value{Value: 42},
+ input: &wrapperspb.UInt32Value{Value: 42},
want: `42`,
}, {
desc: "UInt64Value",
- input: &knownpb.UInt64Value{Value: 42},
+ input: &wrapperspb.UInt64Value{Value: 42},
want: `"42"`,
}, {
desc: "FloatValue",
- input: &knownpb.FloatValue{Value: 1.02},
+ input: &wrapperspb.FloatValue{Value: 1.02},
want: `1.02`,
}, {
desc: "FloatValue Infinity",
- input: &knownpb.FloatValue{Value: float32(math.Inf(-1))},
+ input: &wrapperspb.FloatValue{Value: float32(math.Inf(-1))},
want: `"-Infinity"`,
}, {
desc: "DoubleValue",
- input: &knownpb.DoubleValue{Value: 1.02},
+ input: &wrapperspb.DoubleValue{Value: 1.02},
want: `1.02`,
}, {
desc: "DoubleValue NaN",
- input: &knownpb.DoubleValue{Value: math.NaN()},
+ input: &wrapperspb.DoubleValue{Value: math.NaN()},
want: `"NaN"`,
}, {
desc: "StringValue empty",
- input: &knownpb.StringValue{},
+ input: &wrapperspb.StringValue{},
want: `""`,
}, {
desc: "StringValue",
- input: &knownpb.StringValue{Value: "谷歌"},
+ input: &wrapperspb.StringValue{Value: "谷歌"},
want: `"谷歌"`,
}, {
desc: "StringValue with invalid UTF8 error",
- input: &knownpb.StringValue{Value: "abc\xff"},
+ input: &wrapperspb.StringValue{Value: "abc\xff"},
want: "\"abc\xff\"",
wantErr: true,
}, {
desc: "StringValue field with invalid UTF8 error",
input: &pb2.KnownTypes{
- OptString: &knownpb.StringValue{Value: "abc\xff"},
+ OptString: &wrapperspb.StringValue{Value: "abc\xff"},
},
want: "{\n \"optString\": \"abc\xff\"\n}",
wantErr: true,
}, {
desc: "BytesValue",
- input: &knownpb.BytesValue{Value: []byte("hello")},
+ input: &wrapperspb.BytesValue{Value: []byte("hello")},
want: `"aGVsbG8="`,
}, {
desc: "Empty",
- input: &knownpb.Empty{},
+ input: &emptypb.Empty{},
want: `{}`,
}, {
desc: "NullValue field",
- input: &pb2.KnownTypes{OptNull: new(knownpb.NullValue)},
+ input: &pb2.KnownTypes{OptNull: new(structpb.NullValue)},
want: `{
"optNull": null
}`,
}, {
desc: "Value empty",
- input: &knownpb.Value{},
+ input: &structpb.Value{},
wantErr: true,
}, {
desc: "Value empty field",
input: &pb2.KnownTypes{
- OptValue: &knownpb.Value{},
+ OptValue: &structpb.Value{},
},
wantErr: true,
}, {
desc: "Value contains NullValue",
- input: &knownpb.Value{Kind: &knownpb.Value_NullValue{}},
+ input: &structpb.Value{Kind: &structpb.Value_NullValue{}},
want: `null`,
}, {
desc: "Value contains BoolValue",
- input: &knownpb.Value{Kind: &knownpb.Value_BoolValue{}},
+ input: &structpb.Value{Kind: &structpb.Value_BoolValue{}},
want: `false`,
}, {
desc: "Value contains NumberValue",
- input: &knownpb.Value{Kind: &knownpb.Value_NumberValue{1.02}},
+ input: &structpb.Value{Kind: &structpb.Value_NumberValue{1.02}},
want: `1.02`,
}, {
desc: "Value contains StringValue",
- input: &knownpb.Value{Kind: &knownpb.Value_StringValue{"hello"}},
+ input: &structpb.Value{Kind: &structpb.Value_StringValue{"hello"}},
want: `"hello"`,
}, {
desc: "Value contains StringValue with invalid UTF8",
- input: &knownpb.Value{Kind: &knownpb.Value_StringValue{"\xff"}},
+ input: &structpb.Value{Kind: &structpb.Value_StringValue{"\xff"}},
want: "\"\xff\"",
wantErr: true,
}, {
desc: "Value contains Struct",
- input: &knownpb.Value{
- Kind: &knownpb.Value_StructValue{
- &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "null": {Kind: &knownpb.Value_NullValue{}},
- "number": {Kind: &knownpb.Value_NumberValue{}},
- "string": {Kind: &knownpb.Value_StringValue{}},
- "struct": {Kind: &knownpb.Value_StructValue{}},
- "list": {Kind: &knownpb.Value_ListValue{}},
- "bool": {Kind: &knownpb.Value_BoolValue{}},
+ input: &structpb.Value{
+ Kind: &structpb.Value_StructValue{
+ &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "null": {Kind: &structpb.Value_NullValue{}},
+ "number": {Kind: &structpb.Value_NumberValue{}},
+ "string": {Kind: &structpb.Value_StringValue{}},
+ "struct": {Kind: &structpb.Value_StructValue{}},
+ "list": {Kind: &structpb.Value_ListValue{}},
+ "bool": {Kind: &structpb.Value_BoolValue{}},
},
},
},
@@ -1238,16 +1244,16 @@
}`,
}, {
desc: "Value contains ListValue",
- input: &knownpb.Value{
- Kind: &knownpb.Value_ListValue{
- &knownpb.ListValue{
- Values: []*knownpb.Value{
- {Kind: &knownpb.Value_BoolValue{}},
- {Kind: &knownpb.Value_NullValue{}},
- {Kind: &knownpb.Value_NumberValue{}},
- {Kind: &knownpb.Value_StringValue{}},
- {Kind: &knownpb.Value_StructValue{}},
- {Kind: &knownpb.Value_ListValue{}},
+ input: &structpb.Value{
+ Kind: &structpb.Value_ListValue{
+ &structpb.ListValue{
+ Values: []*structpb.Value{
+ {Kind: &structpb.Value_BoolValue{}},
+ {Kind: &structpb.Value_NullValue{}},
+ {Kind: &structpb.Value_NumberValue{}},
+ {Kind: &structpb.Value_StringValue{}},
+ {Kind: &structpb.Value_StructValue{}},
+ {Kind: &structpb.Value_ListValue{}},
},
},
},
@@ -1262,38 +1268,38 @@
]`,
}, {
desc: "Struct with nil map",
- input: &knownpb.Struct{},
+ input: &structpb.Struct{},
want: `{}`,
}, {
desc: "Struct with empty map",
- input: &knownpb.Struct{
- Fields: map[string]*knownpb.Value{},
+ input: &structpb.Struct{
+ Fields: map[string]*structpb.Value{},
},
want: `{}`,
}, {
desc: "Struct",
- input: &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "bool": {Kind: &knownpb.Value_BoolValue{true}},
- "null": {Kind: &knownpb.Value_NullValue{}},
- "number": {Kind: &knownpb.Value_NumberValue{3.1415}},
- "string": {Kind: &knownpb.Value_StringValue{"hello"}},
+ input: &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "bool": {Kind: &structpb.Value_BoolValue{true}},
+ "null": {Kind: &structpb.Value_NullValue{}},
+ "number": {Kind: &structpb.Value_NumberValue{3.1415}},
+ "string": {Kind: &structpb.Value_StringValue{"hello"}},
"struct": {
- Kind: &knownpb.Value_StructValue{
- &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "string": {Kind: &knownpb.Value_StringValue{"world"}},
+ Kind: &structpb.Value_StructValue{
+ &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "string": {Kind: &structpb.Value_StringValue{"world"}},
},
},
},
},
"list": {
- Kind: &knownpb.Value_ListValue{
- &knownpb.ListValue{
- Values: []*knownpb.Value{
- {Kind: &knownpb.Value_BoolValue{}},
- {Kind: &knownpb.Value_NullValue{}},
- {Kind: &knownpb.Value_NumberValue{}},
+ Kind: &structpb.Value_ListValue{
+ &structpb.ListValue{
+ Values: []*structpb.Value{
+ {Kind: &structpb.Value_BoolValue{}},
+ {Kind: &structpb.Value_NullValue{}},
+ {Kind: &structpb.Value_NumberValue{}},
},
},
},
@@ -1316,47 +1322,47 @@
}`,
}, {
desc: "Struct message with invalid UTF8 string",
- input: &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "string": {Kind: &knownpb.Value_StringValue{"\xff"}},
+ input: &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "string": {Kind: &structpb.Value_StringValue{"\xff"}},
},
},
want: "{\n \"string\": \"\xff\"\n}",
wantErr: true,
}, {
desc: "ListValue with nil values",
- input: &knownpb.ListValue{},
+ input: &structpb.ListValue{},
want: `[]`,
}, {
desc: "ListValue with empty values",
- input: &knownpb.ListValue{
- Values: []*knownpb.Value{},
+ input: &structpb.ListValue{
+ Values: []*structpb.Value{},
},
want: `[]`,
}, {
desc: "ListValue",
- input: &knownpb.ListValue{
- Values: []*knownpb.Value{
- {Kind: &knownpb.Value_BoolValue{true}},
- {Kind: &knownpb.Value_NullValue{}},
- {Kind: &knownpb.Value_NumberValue{3.1415}},
- {Kind: &knownpb.Value_StringValue{"hello"}},
+ input: &structpb.ListValue{
+ Values: []*structpb.Value{
+ {Kind: &structpb.Value_BoolValue{true}},
+ {Kind: &structpb.Value_NullValue{}},
+ {Kind: &structpb.Value_NumberValue{3.1415}},
+ {Kind: &structpb.Value_StringValue{"hello"}},
{
- Kind: &knownpb.Value_ListValue{
- &knownpb.ListValue{
- Values: []*knownpb.Value{
- {Kind: &knownpb.Value_BoolValue{}},
- {Kind: &knownpb.Value_NullValue{}},
- {Kind: &knownpb.Value_NumberValue{}},
+ Kind: &structpb.Value_ListValue{
+ &structpb.ListValue{
+ Values: []*structpb.Value{
+ {Kind: &structpb.Value_BoolValue{}},
+ {Kind: &structpb.Value_NullValue{}},
+ {Kind: &structpb.Value_NumberValue{}},
},
},
},
},
{
- Kind: &knownpb.Value_StructValue{
- &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "string": {Kind: &knownpb.Value_StringValue{"world"}},
+ Kind: &structpb.Value_StructValue{
+ &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "string": {Kind: &structpb.Value_StringValue{"world"}},
},
},
},
@@ -1379,132 +1385,132 @@
]`,
}, {
desc: "ListValue with invalid UTF8 string",
- input: &knownpb.ListValue{
- Values: []*knownpb.Value{
- {Kind: &knownpb.Value_StringValue{"\xff"}},
+ input: &structpb.ListValue{
+ Values: []*structpb.Value{
+ {Kind: &structpb.Value_StringValue{"\xff"}},
},
},
want: "[\n \"\xff\"\n]",
wantErr: true,
}, {
desc: "Duration empty",
- input: &knownpb.Duration{},
+ input: &durationpb.Duration{},
want: `"0s"`,
}, {
desc: "Duration with secs",
- input: &knownpb.Duration{Seconds: 3},
+ input: &durationpb.Duration{Seconds: 3},
want: `"3s"`,
}, {
desc: "Duration with -secs",
- input: &knownpb.Duration{Seconds: -3},
+ input: &durationpb.Duration{Seconds: -3},
want: `"-3s"`,
}, {
desc: "Duration with nanos",
- input: &knownpb.Duration{Nanos: 1e6},
+ input: &durationpb.Duration{Nanos: 1e6},
want: `"0.001s"`,
}, {
desc: "Duration with -nanos",
- input: &knownpb.Duration{Nanos: -1e6},
+ input: &durationpb.Duration{Nanos: -1e6},
want: `"-0.001s"`,
}, {
desc: "Duration with large secs",
- input: &knownpb.Duration{Seconds: 1e10, Nanos: 1},
+ input: &durationpb.Duration{Seconds: 1e10, Nanos: 1},
want: `"10000000000.000000001s"`,
}, {
desc: "Duration with 6-digit nanos",
- input: &knownpb.Duration{Nanos: 1e4},
+ input: &durationpb.Duration{Nanos: 1e4},
want: `"0.000010s"`,
}, {
desc: "Duration with 3-digit nanos",
- input: &knownpb.Duration{Nanos: 1e6},
+ input: &durationpb.Duration{Nanos: 1e6},
want: `"0.001s"`,
}, {
desc: "Duration with -secs -nanos",
- input: &knownpb.Duration{Seconds: -123, Nanos: -450},
+ input: &durationpb.Duration{Seconds: -123, Nanos: -450},
want: `"-123.000000450s"`,
}, {
desc: "Duration max value",
- input: &knownpb.Duration{Seconds: 315576000000, Nanos: 999999999},
+ input: &durationpb.Duration{Seconds: 315576000000, Nanos: 999999999},
want: `"315576000000.999999999s"`,
}, {
desc: "Duration min value",
- input: &knownpb.Duration{Seconds: -315576000000, Nanos: -999999999},
+ input: &durationpb.Duration{Seconds: -315576000000, Nanos: -999999999},
want: `"-315576000000.999999999s"`,
}, {
desc: "Duration with +secs -nanos",
- input: &knownpb.Duration{Seconds: 1, Nanos: -1},
+ input: &durationpb.Duration{Seconds: 1, Nanos: -1},
wantErr: true,
}, {
desc: "Duration with -secs +nanos",
- input: &knownpb.Duration{Seconds: -1, Nanos: 1},
+ input: &durationpb.Duration{Seconds: -1, Nanos: 1},
wantErr: true,
}, {
desc: "Duration with +secs out of range",
- input: &knownpb.Duration{Seconds: 315576000001},
+ input: &durationpb.Duration{Seconds: 315576000001},
wantErr: true,
}, {
desc: "Duration with -secs out of range",
- input: &knownpb.Duration{Seconds: -315576000001},
+ input: &durationpb.Duration{Seconds: -315576000001},
wantErr: true,
}, {
desc: "Duration with +nanos out of range",
- input: &knownpb.Duration{Seconds: 0, Nanos: 1e9},
+ input: &durationpb.Duration{Seconds: 0, Nanos: 1e9},
wantErr: true,
}, {
desc: "Duration with -nanos out of range",
- input: &knownpb.Duration{Seconds: 0, Nanos: -1e9},
+ input: &durationpb.Duration{Seconds: 0, Nanos: -1e9},
wantErr: true,
}, {
desc: "Timestamp zero",
- input: &knownpb.Timestamp{},
+ input: ×tamppb.Timestamp{},
want: `"1970-01-01T00:00:00Z"`,
}, {
desc: "Timestamp",
- input: &knownpb.Timestamp{Seconds: 1553036601},
+ input: ×tamppb.Timestamp{Seconds: 1553036601},
want: `"2019-03-19T23:03:21Z"`,
}, {
desc: "Timestamp with nanos",
- input: &knownpb.Timestamp{Seconds: 1553036601, Nanos: 1},
+ input: ×tamppb.Timestamp{Seconds: 1553036601, Nanos: 1},
want: `"2019-03-19T23:03:21.000000001Z"`,
}, {
desc: "Timestamp with 6-digit nanos",
- input: &knownpb.Timestamp{Nanos: 1e3},
+ input: ×tamppb.Timestamp{Nanos: 1e3},
want: `"1970-01-01T00:00:00.000001Z"`,
}, {
desc: "Timestamp with 3-digit nanos",
- input: &knownpb.Timestamp{Nanos: 1e7},
+ input: ×tamppb.Timestamp{Nanos: 1e7},
want: `"1970-01-01T00:00:00.010Z"`,
}, {
desc: "Timestamp max value",
- input: &knownpb.Timestamp{Seconds: 253402300799, Nanos: 999999999},
+ input: ×tamppb.Timestamp{Seconds: 253402300799, Nanos: 999999999},
want: `"9999-12-31T23:59:59.999999999Z"`,
}, {
desc: "Timestamp min value",
- input: &knownpb.Timestamp{Seconds: -62135596800},
+ input: ×tamppb.Timestamp{Seconds: -62135596800},
want: `"0001-01-01T00:00:00Z"`,
}, {
desc: "Timestamp with +secs out of range",
- input: &knownpb.Timestamp{Seconds: 253402300800},
+ input: ×tamppb.Timestamp{Seconds: 253402300800},
wantErr: true,
}, {
desc: "Timestamp with -secs out of range",
- input: &knownpb.Timestamp{Seconds: -62135596801},
+ input: ×tamppb.Timestamp{Seconds: -62135596801},
wantErr: true,
}, {
desc: "Timestamp with -nanos",
- input: &knownpb.Timestamp{Nanos: -1},
+ input: ×tamppb.Timestamp{Nanos: -1},
wantErr: true,
}, {
desc: "Timestamp with +nanos out of range",
- input: &knownpb.Timestamp{Nanos: 1e9},
+ input: ×tamppb.Timestamp{Nanos: 1e9},
wantErr: true,
}, {
desc: "FieldMask empty",
- input: &knownpb.FieldMask{},
+ input: &fieldmaskpb.FieldMask{},
want: `""`,
}, {
desc: "FieldMask",
- input: &knownpb.FieldMask{
+ input: &fieldmaskpb.FieldMask{
Paths: []string{
"foo",
"foo_bar",
@@ -1515,19 +1521,19 @@
want: `"foo,fooBar,foo.barQux,Foo"`,
}, {
desc: "FieldMask error 1",
- input: &knownpb.FieldMask{
+ input: &fieldmaskpb.FieldMask{
Paths: []string{"foo_"},
},
wantErr: true,
}, {
desc: "FieldMask error 2",
- input: &knownpb.FieldMask{
+ input: &fieldmaskpb.FieldMask{
Paths: []string{"foo__bar"},
},
wantErr: true,
}, {
desc: "Any empty",
- input: &knownpb.Any{},
+ input: &anypb.Any{},
want: `{}`,
}, {
desc: "Any with non-custom message",
@@ -1545,7 +1551,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "foo/pb2.Nested",
Value: b,
}
@@ -1562,14 +1568,14 @@
mo: protojson.MarshalOptions{
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
},
- input: &knownpb.Any{TypeUrl: "foo/pb2.Nested"},
+ input: &anypb.Any{TypeUrl: "foo/pb2.Nested"},
want: `{
"@type": "foo/pb2.Nested"
}`,
}, {
desc: "Any without registered type",
mo: protojson.MarshalOptions{Resolver: preg.NewTypes()},
- input: &knownpb.Any{TypeUrl: "foo/pb2.Nested"},
+ input: &anypb.Any{TypeUrl: "foo/pb2.Nested"},
wantErr: true,
}, {
desc: "Any with missing required error",
@@ -1587,7 +1593,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: string(m.ProtoReflect().Descriptor().FullName()),
Value: b,
}
@@ -1614,7 +1620,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: string(m.ProtoReflect().Descriptor().FullName()),
Value: b,
}
@@ -1636,7 +1642,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "foo/pb2.Nested",
Value: b,
}
@@ -1651,7 +1657,7 @@
mo: protojson.MarshalOptions{
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
},
- input: &knownpb.Any{
+ input: &anypb.Any{
TypeUrl: "foo/pb2.Nested",
Value: dhex("80"),
},
@@ -1659,15 +1665,15 @@
}, {
desc: "Any with BoolValue",
mo: protojson.MarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.BoolValue{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&wrapperspb.BoolValue{})),
},
input: func() proto.Message {
- m := &knownpb.BoolValue{Value: true}
+ m := &wrapperspb.BoolValue{Value: true}
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "type.googleapis.com/google.protobuf.BoolValue",
Value: b,
}
@@ -1679,15 +1685,15 @@
}, {
desc: "Any with Empty",
mo: protojson.MarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.Empty{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&emptypb.Empty{})),
},
input: func() proto.Message {
- m := &knownpb.Empty{}
+ m := &emptypb.Empty{}
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "type.googleapis.com/google.protobuf.Empty",
Value: b,
}
@@ -1699,15 +1705,15 @@
}, {
desc: "Any with StringValue containing invalid UTF8",
mo: protojson.MarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.StringValue{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&wrapperspb.StringValue{})),
},
input: func() proto.Message {
- m := &knownpb.StringValue{Value: "abcd"}
+ m := &wrapperspb.StringValue{Value: "abcd"}
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "google.protobuf.StringValue",
Value: bytes.Replace(b, []byte("abcd"), []byte("abc\xff"), -1),
}
@@ -1720,15 +1726,15 @@
}, {
desc: "Any with Int64Value",
mo: protojson.MarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.Int64Value{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&wrapperspb.Int64Value{})),
},
input: func() proto.Message {
- m := &knownpb.Int64Value{Value: 42}
+ m := &wrapperspb.Int64Value{Value: 42}
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "google.protobuf.Int64Value",
Value: b,
}
@@ -1740,15 +1746,15 @@
}, {
desc: "Any with Duration",
mo: protojson.MarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.Duration{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&durationpb.Duration{})),
},
input: func() proto.Message {
- m := &knownpb.Duration{}
+ m := &durationpb.Duration{}
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "type.googleapis.com/google.protobuf.Duration",
Value: b,
}
@@ -1760,15 +1766,15 @@
}, {
desc: "Any with empty Value",
mo: protojson.MarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.Value{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&structpb.Value{})),
},
input: func() proto.Message {
- m := &knownpb.Value{}
+ m := &structpb.Value{}
b, err := proto.Marshal(m)
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "type.googleapis.com/google.protobuf.Value",
Value: b,
}
@@ -1777,15 +1783,15 @@
}, {
desc: "Any with Value of StringValue",
mo: protojson.MarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.Value{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&structpb.Value{})),
},
input: func() proto.Message {
- m := &knownpb.Value{Kind: &knownpb.Value_StringValue{"abcd"}}
+ m := &structpb.Value{Kind: &structpb.Value_StringValue{"abcd"}}
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "type.googleapis.com/google.protobuf.Value",
Value: bytes.Replace(b, []byte("abcd"), []byte("abc\xff"), -1),
}
@@ -1798,15 +1804,15 @@
}, {
desc: "Any with Value of NullValue",
mo: protojson.MarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.Value{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&structpb.Value{})),
},
input: func() proto.Message {
- m := &knownpb.Value{Kind: &knownpb.Value_NullValue{}}
+ m := &structpb.Value{Kind: &structpb.Value_NullValue{}}
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "type.googleapis.com/google.protobuf.Value",
Value: b,
}
@@ -1819,24 +1825,24 @@
desc: "Any with Struct",
mo: protojson.MarshalOptions{
Resolver: preg.NewTypes(
- pimpl.Export{}.MessageTypeOf(&knownpb.Struct{}),
- pimpl.Export{}.MessageTypeOf(&knownpb.Value{}),
- pimpl.Export{}.MessageTypeOf(&knownpb.BoolValue{}),
- pimpl.Export{}.EnumTypeOf(knownpb.NullValue_NULL_VALUE),
- pimpl.Export{}.MessageTypeOf(&knownpb.StringValue{}),
+ pimpl.Export{}.MessageTypeOf(&structpb.Struct{}),
+ pimpl.Export{}.MessageTypeOf(&structpb.Value{}),
+ pimpl.Export{}.MessageTypeOf(&wrapperspb.BoolValue{}),
+ pimpl.Export{}.EnumTypeOf(structpb.NullValue_NULL_VALUE),
+ pimpl.Export{}.MessageTypeOf(&wrapperspb.StringValue{}),
),
},
input: func() proto.Message {
- m := &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "bool": {Kind: &knownpb.Value_BoolValue{true}},
- "null": {Kind: &knownpb.Value_NullValue{}},
- "string": {Kind: &knownpb.Value_StringValue{"hello"}},
+ m := &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "bool": {Kind: &structpb.Value_BoolValue{true}},
+ "null": {Kind: &structpb.Value_NullValue{}},
+ "string": {Kind: &structpb.Value_StringValue{"hello"}},
"struct": {
- Kind: &knownpb.Value_StructValue{
- &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "string": {Kind: &knownpb.Value_StringValue{"world"}},
+ Kind: &structpb.Value_StructValue{
+ &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "string": {Kind: &structpb.Value_StringValue{"world"}},
},
},
},
@@ -1847,7 +1853,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "google.protobuf.Struct",
Value: b,
}
@@ -1866,15 +1872,15 @@
}, {
desc: "Any with missing type_url",
mo: protojson.MarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.BoolValue{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&wrapperspb.BoolValue{})),
},
input: func() proto.Message {
- m := &knownpb.BoolValue{Value: true}
+ m := &wrapperspb.BoolValue{Value: true}
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
Value: b,
}
}(),
@@ -1882,41 +1888,41 @@
}, {
desc: "well known types as field values",
mo: protojson.MarshalOptions{
- Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&knownpb.Empty{})),
+ Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&emptypb.Empty{})),
},
input: &pb2.KnownTypes{
- OptBool: &knownpb.BoolValue{Value: false},
- OptInt32: &knownpb.Int32Value{Value: 42},
- OptInt64: &knownpb.Int64Value{Value: 42},
- OptUint32: &knownpb.UInt32Value{Value: 42},
- OptUint64: &knownpb.UInt64Value{Value: 42},
- OptFloat: &knownpb.FloatValue{Value: 1.23},
- OptDouble: &knownpb.DoubleValue{Value: 3.1415},
- OptString: &knownpb.StringValue{Value: "hello"},
- OptBytes: &knownpb.BytesValue{Value: []byte("hello")},
- OptDuration: &knownpb.Duration{Seconds: 123},
- OptTimestamp: &knownpb.Timestamp{Seconds: 1553036601},
- OptStruct: &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "string": {Kind: &knownpb.Value_StringValue{"hello"}},
+ OptBool: &wrapperspb.BoolValue{Value: false},
+ OptInt32: &wrapperspb.Int32Value{Value: 42},
+ OptInt64: &wrapperspb.Int64Value{Value: 42},
+ OptUint32: &wrapperspb.UInt32Value{Value: 42},
+ OptUint64: &wrapperspb.UInt64Value{Value: 42},
+ OptFloat: &wrapperspb.FloatValue{Value: 1.23},
+ OptDouble: &wrapperspb.DoubleValue{Value: 3.1415},
+ OptString: &wrapperspb.StringValue{Value: "hello"},
+ OptBytes: &wrapperspb.BytesValue{Value: []byte("hello")},
+ OptDuration: &durationpb.Duration{Seconds: 123},
+ OptTimestamp: ×tamppb.Timestamp{Seconds: 1553036601},
+ OptStruct: &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "string": {Kind: &structpb.Value_StringValue{"hello"}},
},
},
- OptList: &knownpb.ListValue{
- Values: []*knownpb.Value{
- {Kind: &knownpb.Value_NullValue{}},
- {Kind: &knownpb.Value_StringValue{}},
- {Kind: &knownpb.Value_StructValue{}},
- {Kind: &knownpb.Value_ListValue{}},
+ OptList: &structpb.ListValue{
+ Values: []*structpb.Value{
+ {Kind: &structpb.Value_NullValue{}},
+ {Kind: &structpb.Value_StringValue{}},
+ {Kind: &structpb.Value_StructValue{}},
+ {Kind: &structpb.Value_ListValue{}},
},
},
- OptValue: &knownpb.Value{
- Kind: &knownpb.Value_StringValue{"world"},
+ OptValue: &structpb.Value{
+ Kind: &structpb.Value_StringValue{"world"},
},
- OptEmpty: &knownpb.Empty{},
- OptAny: &knownpb.Any{
+ OptEmpty: &emptypb.Empty{},
+ OptAny: &anypb.Any{
TypeUrl: "google.protobuf.Empty",
},
- OptFieldmask: &knownpb.FieldMask{
+ OptFieldmask: &fieldmaskpb.FieldMask{
Paths: []string{"foo_bar", "bar_foo"},
},
},
diff --git a/encoding/prototext/decode_test.go b/encoding/prototext/decode_test.go
index 20fcc94..39d470a 100644
--- a/encoding/prototext/decode_test.go
+++ b/encoding/prototext/decode_test.go
@@ -18,7 +18,7 @@
"google.golang.org/protobuf/encoding/testprotos/pb2"
"google.golang.org/protobuf/encoding/testprotos/pb3"
- knownpb "google.golang.org/protobuf/types/known"
+ "google.golang.org/protobuf/types/known/anypb"
)
func TestUnmarshal(t *testing.T) {
@@ -1365,27 +1365,27 @@
}(),
}, {
desc: "Any not expanded",
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `
type_url: "pb2.Nested"
value: "some bytes"
`,
- wantMessage: &knownpb.Any{
+ wantMessage: &anypb.Any{
TypeUrl: "pb2.Nested",
Value: []byte("some bytes"),
},
}, {
desc: "Any not expanded missing value",
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `type_url: "pb2.Nested"`,
- wantMessage: &knownpb.Any{
+ wantMessage: &anypb.Any{
TypeUrl: "pb2.Nested",
},
}, {
desc: "Any not expanded missing type_url",
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `value: "some bytes"`,
- wantMessage: &knownpb.Any{
+ wantMessage: &anypb.Any{
Value: []byte("some bytes"),
},
}, {
@@ -1393,7 +1393,7 @@
umo: prototext.UnmarshalOptions{
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `
[foobar/pb2.Nested]: {
opt_string: "embedded inside Any"
@@ -1413,7 +1413,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "foobar/pb2.Nested",
Value: b,
}
@@ -1423,9 +1423,9 @@
umo: prototext.UnmarshalOptions{
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `[foo.com/pb2.Nested]: {}`,
- wantMessage: &knownpb.Any{
+ wantMessage: &anypb.Any{
TypeUrl: "foo.com/pb2.Nested",
},
}, {
@@ -1433,7 +1433,7 @@
umo: prototext.UnmarshalOptions{
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.PartialRequired{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `
[pb2.PartialRequired]: {
opt_string: "embedded inside Any"
@@ -1450,7 +1450,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "pb2.PartialRequired",
Value: b,
}
@@ -1461,7 +1461,7 @@
umo: prototext.UnmarshalOptions{
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb3.Nested{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `
[pb3.Nested]: {
s_string: "abc\xff"
@@ -1476,7 +1476,7 @@
if !nerr.Merge(err) {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: string(m.ProtoReflect().Descriptor().FullName()),
Value: b,
}
@@ -1485,7 +1485,7 @@
}, {
desc: "Any expanded with unregistered type",
umo: prototext.UnmarshalOptions{Resolver: preg.NewTypes()},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `[SomeMessage]: {}`,
wantErr: true,
}, {
@@ -1493,7 +1493,7 @@
umo: prototext.UnmarshalOptions{
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `[pb2.Nested]: 123`,
wantErr: true,
}, {
@@ -1501,7 +1501,7 @@
umo: prototext.UnmarshalOptions{
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `
[pb2.Nested]: {}
unknown: ""
@@ -1512,7 +1512,7 @@
umo: prototext.UnmarshalOptions{
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
},
- inputMessage: &knownpb.Any{},
+ inputMessage: &anypb.Any{},
inputText: `
[pb2.Nested]: {}
type_url: "pb2.Nested"
diff --git a/encoding/prototext/encode_test.go b/encoding/prototext/encode_test.go
index b2fc57b..98732bc 100644
--- a/encoding/prototext/encode_test.go
+++ b/encoding/prototext/encode_test.go
@@ -25,7 +25,7 @@
"google.golang.org/protobuf/encoding/testprotos/pb2"
"google.golang.org/protobuf/encoding/testprotos/pb3"
- knownpb "google.golang.org/protobuf/types/known"
+ "google.golang.org/protobuf/types/known/anypb"
)
func init() {
@@ -1181,7 +1181,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "pb2.Nested",
Value: b,
}
@@ -1205,7 +1205,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: "foo/pb2.Nested",
Value: b,
}
@@ -1233,7 +1233,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: string(m.ProtoReflect().Descriptor().FullName()),
Value: b,
}
@@ -1256,7 +1256,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- return &knownpb.Any{
+ return &anypb.Any{
TypeUrl: string(m.ProtoReflect().Descriptor().FullName()),
Value: bytes.Replace(b, []byte("abcd"), []byte("abc\xff"), -1),
}
@@ -1271,7 +1271,7 @@
mo: prototext.MarshalOptions{
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
},
- input: &knownpb.Any{
+ input: &anypb.Any{
TypeUrl: "foo/pb2.Nested",
Value: dhex("80"),
},
diff --git a/encoding/prototext/other_test.go b/encoding/prototext/other_test.go
index 8262099..978a358 100644
--- a/encoding/prototext/other_test.go
+++ b/encoding/prototext/other_test.go
@@ -12,7 +12,12 @@
preg "google.golang.org/protobuf/reflect/protoregistry"
"google.golang.org/protobuf/encoding/testprotos/pb2"
- knownpb "google.golang.org/protobuf/types/known"
+ "google.golang.org/protobuf/types/known/anypb"
+ "google.golang.org/protobuf/types/known/durationpb"
+ "google.golang.org/protobuf/types/known/emptypb"
+ "google.golang.org/protobuf/types/known/structpb"
+ "google.golang.org/protobuf/types/known/timestamppb"
+ "google.golang.org/protobuf/types/known/wrapperspb"
)
func TestRoundTrip(t *testing.T) {
@@ -23,62 +28,62 @@
}{{
desc: "well-known type fields set to empty messages",
message: &pb2.KnownTypes{
- OptBool: &knownpb.BoolValue{},
- OptInt32: &knownpb.Int32Value{},
- OptInt64: &knownpb.Int64Value{},
- OptUint32: &knownpb.UInt32Value{},
- OptUint64: &knownpb.UInt64Value{},
- OptFloat: &knownpb.FloatValue{},
- OptDouble: &knownpb.DoubleValue{},
- OptString: &knownpb.StringValue{},
- OptBytes: &knownpb.BytesValue{},
- OptDuration: &knownpb.Duration{},
- OptTimestamp: &knownpb.Timestamp{},
- OptStruct: &knownpb.Struct{},
- OptList: &knownpb.ListValue{},
- OptValue: &knownpb.Value{},
- OptEmpty: &knownpb.Empty{},
- OptAny: &knownpb.Any{},
+ OptBool: &wrapperspb.BoolValue{},
+ OptInt32: &wrapperspb.Int32Value{},
+ OptInt64: &wrapperspb.Int64Value{},
+ OptUint32: &wrapperspb.UInt32Value{},
+ OptUint64: &wrapperspb.UInt64Value{},
+ OptFloat: &wrapperspb.FloatValue{},
+ OptDouble: &wrapperspb.DoubleValue{},
+ OptString: &wrapperspb.StringValue{},
+ OptBytes: &wrapperspb.BytesValue{},
+ OptDuration: &durationpb.Duration{},
+ OptTimestamp: ×tamppb.Timestamp{},
+ OptStruct: &structpb.Struct{},
+ OptList: &structpb.ListValue{},
+ OptValue: &structpb.Value{},
+ OptEmpty: &emptypb.Empty{},
+ OptAny: &anypb.Any{},
},
}, {
desc: "well-known type scalar fields",
message: &pb2.KnownTypes{
- OptBool: &knownpb.BoolValue{
+ OptBool: &wrapperspb.BoolValue{
Value: true,
},
- OptInt32: &knownpb.Int32Value{
+ OptInt32: &wrapperspb.Int32Value{
Value: -42,
},
- OptInt64: &knownpb.Int64Value{
+ OptInt64: &wrapperspb.Int64Value{
Value: -42,
},
- OptUint32: &knownpb.UInt32Value{
+ OptUint32: &wrapperspb.UInt32Value{
Value: 0xff,
},
- OptUint64: &knownpb.UInt64Value{
+ OptUint64: &wrapperspb.UInt64Value{
Value: 0xffff,
},
- OptFloat: &knownpb.FloatValue{
+ OptFloat: &wrapperspb.FloatValue{
Value: 1.234,
},
- OptDouble: &knownpb.DoubleValue{
+ OptDouble: &wrapperspb.DoubleValue{
Value: 1.23e308,
},
- OptString: &knownpb.StringValue{
+ OptString: &wrapperspb.StringValue{
Value: "谷歌",
},
- OptBytes: &knownpb.BytesValue{
+ OptBytes: &wrapperspb.BytesValue{
Value: []byte("\xe8\xb0\xb7\xe6\xad\x8c"),
},
},
}, {
desc: "well-known type time-related fields",
message: &pb2.KnownTypes{
- OptDuration: &knownpb.Duration{
+ OptDuration: &durationpb.Duration{
Seconds: -3600,
Nanos: -123,
},
- OptTimestamp: &knownpb.Timestamp{
+ OptTimestamp: ×tamppb.Timestamp{
Seconds: 1257894000,
Nanos: 123,
},
@@ -86,34 +91,34 @@
}, {
desc: "Struct field and different Value types",
message: &pb2.KnownTypes{
- OptStruct: &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "bool": &knownpb.Value{
- Kind: &knownpb.Value_BoolValue{
+ OptStruct: &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "bool": &structpb.Value{
+ Kind: &structpb.Value_BoolValue{
BoolValue: true,
},
},
- "double": &knownpb.Value{
- Kind: &knownpb.Value_NumberValue{
+ "double": &structpb.Value{
+ Kind: &structpb.Value_NumberValue{
NumberValue: 3.1415,
},
},
- "null": &knownpb.Value{
- Kind: &knownpb.Value_NullValue{
- NullValue: knownpb.NullValue_NULL_VALUE,
+ "null": &structpb.Value{
+ Kind: &structpb.Value_NullValue{
+ NullValue: structpb.NullValue_NULL_VALUE,
},
},
- "string": &knownpb.Value{
- Kind: &knownpb.Value_StringValue{
+ "string": &structpb.Value{
+ Kind: &structpb.Value_StringValue{
StringValue: "string",
},
},
- "struct": &knownpb.Value{
- Kind: &knownpb.Value_StructValue{
- StructValue: &knownpb.Struct{
- Fields: map[string]*knownpb.Value{
- "bool": &knownpb.Value{
- Kind: &knownpb.Value_BoolValue{
+ "struct": &structpb.Value{
+ Kind: &structpb.Value_StructValue{
+ StructValue: &structpb.Struct{
+ Fields: map[string]*structpb.Value{
+ "bool": &structpb.Value{
+ Kind: &structpb.Value_BoolValue{
BoolValue: false,
},
},
@@ -121,17 +126,17 @@
},
},
},
- "list": &knownpb.Value{
- Kind: &knownpb.Value_ListValue{
- ListValue: &knownpb.ListValue{
- Values: []*knownpb.Value{
+ "list": &structpb.Value{
+ Kind: &structpb.Value_ListValue{
+ ListValue: &structpb.ListValue{
+ Values: []*structpb.Value{
{
- Kind: &knownpb.Value_BoolValue{
+ Kind: &structpb.Value_BoolValue{
BoolValue: false,
},
},
{
- Kind: &knownpb.Value_StringValue{
+ Kind: &structpb.Value_StringValue{
StringValue: "hello",
},
},
@@ -157,7 +162,7 @@
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
return &pb2.KnownTypes{
- OptAny: &knownpb.Any{
+ OptAny: &anypb.Any{
TypeUrl: string(m.ProtoReflect().Descriptor().FullName()),
Value: b,
},
@@ -178,7 +183,7 @@
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
return &pb2.KnownTypes{
- OptAny: &knownpb.Any{
+ OptAny: &anypb.Any{
TypeUrl: string(m.ProtoReflect().Descriptor().FullName()),
Value: b,
},
@@ -188,7 +193,7 @@
desc: "Any field containing Any message",
resolver: func() *preg.Types {
mt1 := impl.Export{}.MessageTypeOf(&pb2.Nested{})
- mt2 := impl.Export{}.MessageTypeOf(&knownpb.Any{})
+ mt2 := impl.Export{}.MessageTypeOf(&anypb.Any{})
return preg.NewTypes(mt1, mt2)
}(),
message: func() *pb2.KnownTypes {
@@ -199,7 +204,7 @@
if err != nil {
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
- m2 := &knownpb.Any{
+ m2 := &anypb.Any{
TypeUrl: "pb2.Nested",
Value: b1,
}
@@ -208,7 +213,7 @@
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
}
return &pb2.KnownTypes{
- OptAny: &knownpb.Any{
+ OptAny: &anypb.Any{
TypeUrl: "google.protobuf.Any",
Value: b2,
},
diff --git a/encoding/testprotos/pb2/test.pb.go b/encoding/testprotos/pb2/test.pb.go
index 80f90d0..bc90995 100644
--- a/encoding/testprotos/pb2/test.pb.go
+++ b/encoding/testprotos/pb2/test.pb.go
@@ -8,7 +8,13 @@
protoregistry "google.golang.org/protobuf/reflect/protoregistry"
protoiface "google.golang.org/protobuf/runtime/protoiface"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
- known "google.golang.org/protobuf/types/known"
+ anypb "google.golang.org/protobuf/types/known/anypb"
+ durationpb "google.golang.org/protobuf/types/known/durationpb"
+ emptypb "google.golang.org/protobuf/types/known/emptypb"
+ fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"
+ structpb "google.golang.org/protobuf/types/known/structpb"
+ timestamppb "google.golang.org/protobuf/types/known/timestamppb"
+ wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
sync "sync"
)
@@ -1050,24 +1056,24 @@
// Message contains well-known type fields.
type KnownTypes struct {
- OptBool *known.BoolValue `protobuf:"bytes,1,opt,name=opt_bool,json=optBool" json:"opt_bool,omitempty"`
- OptInt32 *known.Int32Value `protobuf:"bytes,2,opt,name=opt_int32,json=optInt32" json:"opt_int32,omitempty"`
- OptInt64 *known.Int64Value `protobuf:"bytes,3,opt,name=opt_int64,json=optInt64" json:"opt_int64,omitempty"`
- OptUint32 *known.UInt32Value `protobuf:"bytes,4,opt,name=opt_uint32,json=optUint32" json:"opt_uint32,omitempty"`
- OptUint64 *known.UInt64Value `protobuf:"bytes,5,opt,name=opt_uint64,json=optUint64" json:"opt_uint64,omitempty"`
- OptFloat *known.FloatValue `protobuf:"bytes,6,opt,name=opt_float,json=optFloat" json:"opt_float,omitempty"`
- OptDouble *known.DoubleValue `protobuf:"bytes,7,opt,name=opt_double,json=optDouble" json:"opt_double,omitempty"`
- OptString *known.StringValue `protobuf:"bytes,8,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
- OptBytes *known.BytesValue `protobuf:"bytes,9,opt,name=opt_bytes,json=optBytes" json:"opt_bytes,omitempty"`
- OptDuration *known.Duration `protobuf:"bytes,20,opt,name=opt_duration,json=optDuration" json:"opt_duration,omitempty"`
- OptTimestamp *known.Timestamp `protobuf:"bytes,21,opt,name=opt_timestamp,json=optTimestamp" json:"opt_timestamp,omitempty"`
- OptStruct *known.Struct `protobuf:"bytes,25,opt,name=opt_struct,json=optStruct" json:"opt_struct,omitempty"`
- OptList *known.ListValue `protobuf:"bytes,26,opt,name=opt_list,json=optList" json:"opt_list,omitempty"`
- OptValue *known.Value `protobuf:"bytes,27,opt,name=opt_value,json=optValue" json:"opt_value,omitempty"`
- OptNull *known.NullValue `protobuf:"varint,28,opt,name=opt_null,json=optNull,enum=google.protobuf.NullValue" json:"opt_null,omitempty"`
- OptEmpty *known.Empty `protobuf:"bytes,30,opt,name=opt_empty,json=optEmpty" json:"opt_empty,omitempty"`
- OptAny *known.Any `protobuf:"bytes,32,opt,name=opt_any,json=optAny" json:"opt_any,omitempty"`
- OptFieldmask *known.FieldMask `protobuf:"bytes,40,opt,name=opt_fieldmask,json=optFieldmask" json:"opt_fieldmask,omitempty"`
+ OptBool *wrapperspb.BoolValue `protobuf:"bytes,1,opt,name=opt_bool,json=optBool" json:"opt_bool,omitempty"`
+ OptInt32 *wrapperspb.Int32Value `protobuf:"bytes,2,opt,name=opt_int32,json=optInt32" json:"opt_int32,omitempty"`
+ OptInt64 *wrapperspb.Int64Value `protobuf:"bytes,3,opt,name=opt_int64,json=optInt64" json:"opt_int64,omitempty"`
+ OptUint32 *wrapperspb.UInt32Value `protobuf:"bytes,4,opt,name=opt_uint32,json=optUint32" json:"opt_uint32,omitempty"`
+ OptUint64 *wrapperspb.UInt64Value `protobuf:"bytes,5,opt,name=opt_uint64,json=optUint64" json:"opt_uint64,omitempty"`
+ OptFloat *wrapperspb.FloatValue `protobuf:"bytes,6,opt,name=opt_float,json=optFloat" json:"opt_float,omitempty"`
+ OptDouble *wrapperspb.DoubleValue `protobuf:"bytes,7,opt,name=opt_double,json=optDouble" json:"opt_double,omitempty"`
+ OptString *wrapperspb.StringValue `protobuf:"bytes,8,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
+ OptBytes *wrapperspb.BytesValue `protobuf:"bytes,9,opt,name=opt_bytes,json=optBytes" json:"opt_bytes,omitempty"`
+ OptDuration *durationpb.Duration `protobuf:"bytes,20,opt,name=opt_duration,json=optDuration" json:"opt_duration,omitempty"`
+ OptTimestamp *timestamppb.Timestamp `protobuf:"bytes,21,opt,name=opt_timestamp,json=optTimestamp" json:"opt_timestamp,omitempty"`
+ OptStruct *structpb.Struct `protobuf:"bytes,25,opt,name=opt_struct,json=optStruct" json:"opt_struct,omitempty"`
+ OptList *structpb.ListValue `protobuf:"bytes,26,opt,name=opt_list,json=optList" json:"opt_list,omitempty"`
+ OptValue *structpb.Value `protobuf:"bytes,27,opt,name=opt_value,json=optValue" json:"opt_value,omitempty"`
+ OptNull *structpb.NullValue `protobuf:"varint,28,opt,name=opt_null,json=optNull,enum=google.protobuf.NullValue" json:"opt_null,omitempty"`
+ OptEmpty *emptypb.Empty `protobuf:"bytes,30,opt,name=opt_empty,json=optEmpty" json:"opt_empty,omitempty"`
+ OptAny *anypb.Any `protobuf:"bytes,32,opt,name=opt_any,json=optAny" json:"opt_any,omitempty"`
+ OptFieldmask *fieldmaskpb.FieldMask `protobuf:"bytes,40,opt,name=opt_fieldmask,json=optFieldmask" json:"opt_fieldmask,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized protoimpl.UnknownFields `json:"-"`
XXX_sizecache protoimpl.SizeCache `json:"-"`
@@ -1096,126 +1102,126 @@
return file_pb2_test_proto_rawDescGZIP(), []int{15}
}
-func (x *KnownTypes) GetOptBool() *known.BoolValue {
+func (x *KnownTypes) GetOptBool() *wrapperspb.BoolValue {
if x != nil {
return x.OptBool
}
return nil
}
-func (x *KnownTypes) GetOptInt32() *known.Int32Value {
+func (x *KnownTypes) GetOptInt32() *wrapperspb.Int32Value {
if x != nil {
return x.OptInt32
}
return nil
}
-func (x *KnownTypes) GetOptInt64() *known.Int64Value {
+func (x *KnownTypes) GetOptInt64() *wrapperspb.Int64Value {
if x != nil {
return x.OptInt64
}
return nil
}
-func (x *KnownTypes) GetOptUint32() *known.UInt32Value {
+func (x *KnownTypes) GetOptUint32() *wrapperspb.UInt32Value {
if x != nil {
return x.OptUint32
}
return nil
}
-func (x *KnownTypes) GetOptUint64() *known.UInt64Value {
+func (x *KnownTypes) GetOptUint64() *wrapperspb.UInt64Value {
if x != nil {
return x.OptUint64
}
return nil
}
-func (x *KnownTypes) GetOptFloat() *known.FloatValue {
+func (x *KnownTypes) GetOptFloat() *wrapperspb.FloatValue {
if x != nil {
return x.OptFloat
}
return nil
}
-func (x *KnownTypes) GetOptDouble() *known.DoubleValue {
+func (x *KnownTypes) GetOptDouble() *wrapperspb.DoubleValue {
if x != nil {
return x.OptDouble
}
return nil
}
-func (x *KnownTypes) GetOptString() *known.StringValue {
+func (x *KnownTypes) GetOptString() *wrapperspb.StringValue {
if x != nil {
return x.OptString
}
return nil
}
-func (x *KnownTypes) GetOptBytes() *known.BytesValue {
+func (x *KnownTypes) GetOptBytes() *wrapperspb.BytesValue {
if x != nil {
return x.OptBytes
}
return nil
}
-func (x *KnownTypes) GetOptDuration() *known.Duration {
+func (x *KnownTypes) GetOptDuration() *durationpb.Duration {
if x != nil {
return x.OptDuration
}
return nil
}
-func (x *KnownTypes) GetOptTimestamp() *known.Timestamp {
+func (x *KnownTypes) GetOptTimestamp() *timestamppb.Timestamp {
if x != nil {
return x.OptTimestamp
}
return nil
}
-func (x *KnownTypes) GetOptStruct() *known.Struct {
+func (x *KnownTypes) GetOptStruct() *structpb.Struct {
if x != nil {
return x.OptStruct
}
return nil
}
-func (x *KnownTypes) GetOptList() *known.ListValue {
+func (x *KnownTypes) GetOptList() *structpb.ListValue {
if x != nil {
return x.OptList
}
return nil
}
-func (x *KnownTypes) GetOptValue() *known.Value {
+func (x *KnownTypes) GetOptValue() *structpb.Value {
if x != nil {
return x.OptValue
}
return nil
}
-func (x *KnownTypes) GetOptNull() known.NullValue {
+func (x *KnownTypes) GetOptNull() structpb.NullValue {
if x != nil && x.OptNull != nil {
return *x.OptNull
}
- return known.NullValue_NULL_VALUE
+ return structpb.NullValue_NULL_VALUE
}
-func (x *KnownTypes) GetOptEmpty() *known.Empty {
+func (x *KnownTypes) GetOptEmpty() *emptypb.Empty {
if x != nil {
return x.OptEmpty
}
return nil
}
-func (x *KnownTypes) GetOptAny() *known.Any {
+func (x *KnownTypes) GetOptAny() *anypb.Any {
if x != nil {
return x.OptAny
}
return nil
}
-func (x *KnownTypes) GetOptFieldmask() *known.FieldMask {
+func (x *KnownTypes) GetOptFieldmask() *fieldmaskpb.FieldMask {
if x != nil {
return x.OptFieldmask
}
@@ -1965,24 +1971,24 @@
(*Nests_RptGroup)(nil), // 19: pb2.Nests.RptGroup
(*Nests_OptGroup_OptNestedGroup)(nil), // 20: pb2.Nests.OptGroup.OptNestedGroup
nil, // 21: pb2.IndirectRequired.StrToNestedEntry
- (*known.BoolValue)(nil), // 22: google.protobuf.BoolValue
- (*known.Int32Value)(nil), // 23: google.protobuf.Int32Value
- (*known.Int64Value)(nil), // 24: google.protobuf.Int64Value
- (*known.UInt32Value)(nil), // 25: google.protobuf.UInt32Value
- (*known.UInt64Value)(nil), // 26: google.protobuf.UInt64Value
- (*known.FloatValue)(nil), // 27: google.protobuf.FloatValue
- (*known.DoubleValue)(nil), // 28: google.protobuf.DoubleValue
- (*known.StringValue)(nil), // 29: google.protobuf.StringValue
- (*known.BytesValue)(nil), // 30: google.protobuf.BytesValue
- (*known.Duration)(nil), // 31: google.protobuf.Duration
- (*known.Timestamp)(nil), // 32: google.protobuf.Timestamp
- (*known.Struct)(nil), // 33: google.protobuf.Struct
- (*known.ListValue)(nil), // 34: google.protobuf.ListValue
- (*known.Value)(nil), // 35: google.protobuf.Value
- (known.NullValue)(0), // 36: google.protobuf.NullValue
- (*known.Empty)(nil), // 37: google.protobuf.Empty
- (*known.Any)(nil), // 38: google.protobuf.Any
- (*known.FieldMask)(nil), // 39: google.protobuf.FieldMask
+ (*wrapperspb.BoolValue)(nil), // 22: google.protobuf.BoolValue
+ (*wrapperspb.Int32Value)(nil), // 23: google.protobuf.Int32Value
+ (*wrapperspb.Int64Value)(nil), // 24: google.protobuf.Int64Value
+ (*wrapperspb.UInt32Value)(nil), // 25: google.protobuf.UInt32Value
+ (*wrapperspb.UInt64Value)(nil), // 26: google.protobuf.UInt64Value
+ (*wrapperspb.FloatValue)(nil), // 27: google.protobuf.FloatValue
+ (*wrapperspb.DoubleValue)(nil), // 28: google.protobuf.DoubleValue
+ (*wrapperspb.StringValue)(nil), // 29: google.protobuf.StringValue
+ (*wrapperspb.BytesValue)(nil), // 30: google.protobuf.BytesValue
+ (*durationpb.Duration)(nil), // 31: google.protobuf.Duration
+ (*timestamppb.Timestamp)(nil), // 32: google.protobuf.Timestamp
+ (*structpb.Struct)(nil), // 33: google.protobuf.Struct
+ (*structpb.ListValue)(nil), // 34: google.protobuf.ListValue
+ (*structpb.Value)(nil), // 35: google.protobuf.Value
+ (structpb.NullValue)(0), // 36: google.protobuf.NullValue
+ (*emptypb.Empty)(nil), // 37: google.protobuf.Empty
+ (*anypb.Any)(nil), // 38: google.protobuf.Any
+ (*fieldmaskpb.FieldMask)(nil), // 39: google.protobuf.FieldMask
}
var file_pb2_test_proto_depIdxs = []int32{
11, // pb2.opt_ext_bool:extendee -> pb2.Extensions