perso/syncthing-arm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

vendor: Update everything

Browse Source 
GitHub-Pull-Request: https://github.com/syncthing/syncthing/pull/4620
This commit is contained in:
Jakob Borg
2017-12-29 11:38:00 +00:00
parent 1296a22069
commit c24bf7ea55
1070 changed files with 294926 additions and 488191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

261
vendor/github.com/gogo/protobuf/jsonpb/jsonpb.go generated vendored
View File

@@ -44,6 +44,7 @@ import (
"errors"
"fmt"
"io"
"math"
"reflect"
"sort"
"strconv"
@@ -71,6 +72,31 @@ type Marshaler struct {
// Whether to use the original (.proto) name for fields.
OrigName bool
// A custom URL resolver to use when marshaling Any messages to JSON.
// If unset, the default resolution strategy is to extract the
// fully-qualified type name from the type URL and pass that to
// proto.MessageType(string).
AnyResolver AnyResolver
}
// AnyResolver takes a type URL, present in an Any message, and resolves it into
// an instance of the associated message.
type AnyResolver interface {
Resolve(typeUrl string) (proto.Message, error)
}
func defaultResolveAny(typeUrl string) (proto.Message, error) {
// Only the part of typeUrl after the last slash is relevant.
mname := typeUrl
if slash := strings.LastIndex(mname, "/"); slash >= 0 {
mname = mname[slash+1:]
}
mt := proto.MessageType(mname)
if mt == nil {
return nil, fmt.Errorf("unknown message type %q", mname)
}
return reflect.New(mt.Elem()).Interface().(proto.Message), nil
}
// JSONPBMarshaler is implemented by protobuf messages that customize the
@@ -106,6 +132,12 @@ func (m *Marshaler) MarshalToString(pb proto.Message) (string, error) {
type int32Slice []int32
var nonFinite = map[string]float64{
`"NaN"`: math.NaN(),
`"Infinity"`: math.Inf(1),
`"-Infinity"`: math.Inf(-1),
}
// For sorting extensions ids to ensure stable output.
func (s int32Slice) Len() int { return len(s) }
func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] }
@@ -122,6 +154,22 @@ func (m *Marshaler) marshalObject(out *errWriter, v proto.Message, indent, typeU
if err != nil {
return err
}
if typeURL != "" {
// we are marshaling this object to an Any type
var js map[string]*json.RawMessage
if err = json.Unmarshal(b, &js); err != nil {
return fmt.Errorf("type %T produced invalid JSON: %v", v, err)
}
turl, err := json.Marshal(typeURL)
if err != nil {
return fmt.Errorf("failed to marshal type URL %q to JSON: %v", typeURL, err)
}
js["@type"] = (*json.RawMessage)(&turl)
if b, err = json.Marshal(js); err != nil {
return err
}
}
out.write(string(b))
return out.err
}
@@ -204,6 +252,11 @@ func (m *Marshaler) marshalObject(out *errWriter, v proto.Message, indent, typeU
continue
}
//this is not a protobuf field
if valueField.Tag.Get("protobuf") == "" && valueField.Tag.Get("protobuf_oneof") == "" {
continue
}
// IsNil will panic on most value kinds.
switch value.Kind() {
case reflect.Chan, reflect.Func, reflect.Interface:
@@ -336,16 +389,17 @@ func (m *Marshaler) marshalAny(out *errWriter, any proto.Message, indent string)
turl := v.Field(0).String()
val := v.Field(1).Bytes()
// Only the part of type_url after the last slash is relevant.
mname := turl
if slash := strings.LastIndex(mname, "/"); slash >= 0 {
mname = mname[slash+1:]
var msg proto.Message
var err error
if m.AnyResolver != nil {
msg, err = m.AnyResolver.Resolve(turl)
} else {
msg, err = defaultResolveAny(turl)
}
mt := proto.MessageType(mname)
if mt == nil {
return fmt.Errorf("unknown message type %q", mname)
if err != nil {
return err
}
msg := reflect.New(mt.Elem()).Interface().(proto.Message)
if err := proto.Unmarshal(val, msg); err != nil {
return err
}
@@ -606,6 +660,24 @@ func (m *Marshaler) marshalValue(out *errWriter, prop *proto.Properties, v refle
return out.err
}
// Handle non-finite floats, e.g. NaN, Infinity and -Infinity.
if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
f := v.Float()
var sval string
switch {
case math.IsInf(f, 1):
sval = `"Infinity"`
case math.IsInf(f, -1):
sval = `"-Infinity"`
case math.IsNaN(f):
sval = `"NaN"`
}
if sval != "" {
out.write(sval)
return out.err
}
}
// Default handling defers to the encoding/json library.
b, err := json.Marshal(v.Interface())
if err != nil {
@@ -628,6 +700,12 @@ type Unmarshaler struct {
// Whether to allow messages to contain unknown fields, as opposed to
// failing to unmarshal.
AllowUnknownFields bool
// A custom URL resolver to use when unmarshaling Any messages from JSON.
// If unset, the default resolution strategy is to extract the
// fully-qualified type name from the type URL and pass that to
// proto.MessageType(string).
AnyResolver AnyResolver
}
// UnmarshalNext unmarshals the next protocol buffer from a JSON object stream.
@@ -677,7 +755,14 @@ func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMe
// Allocate memory for pointer fields.
if targetType.Kind() == reflect.Ptr {
// If input value is "null" and target is a pointer type, then the field should be treated as not set
// UNLESS the target is structpb.Value, in which case it should be set to structpb.NullValue.
_, isJSONPBUnmarshaler := target.Interface().(JSONPBUnmarshaler)
if string(inputValue) == "null" && targetType != reflect.TypeOf(&types.Value{}) && !isJSONPBUnmarshaler {
return nil
}
target.Set(reflect.New(targetType.Elem()))
return u.unmarshalValue(target.Elem(), inputValue, prop)
}
@@ -685,87 +770,82 @@ func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMe
return jsu.UnmarshalJSONPB(u, []byte(inputValue))
}
// Handle well-known types.
// Handle well-known types that are not pointers.
if w, ok := target.Addr().Interface().(isWkt); ok {
switch w.XXX_WellKnownType() {
case "DoubleValue", "FloatValue", "Int64Value", "UInt64Value",
"Int32Value", "UInt32Value", "BoolValue", "StringValue", "BytesValue":
// "Wrappers use the same representation in JSON
// as the wrapped primitive type, except that null is allowed."
// encoding/json will turn JSON `null` into Go `nil`,
// so we don't have to do any extra work.
return u.unmarshalValue(target.Field(0), inputValue, prop)
case "Any":
var jsonFields map[string]json.RawMessage
// Use json.RawMessage pointer type instead of value to support pre-1.8 version.
// 1.8 changed RawMessage.MarshalJSON from pointer type to value type, see
// https://github.com/golang/go/issues/14493
var jsonFields map[string]*json.RawMessage
if err := json.Unmarshal(inputValue, &jsonFields); err != nil {
return err
}
val, ok := jsonFields["@type"]
if !ok {
if !ok || val == nil {
return errors.New("Any JSON doesn't have '@type'")
}
var turl string
if err := json.Unmarshal([]byte(val), &turl); err != nil {
return fmt.Errorf("can't unmarshal Any's '@type': %q", val)
if err := json.Unmarshal([]byte(*val), &turl); err != nil {
return fmt.Errorf("can't unmarshal Any's '@type': %q", *val)
}
target.Field(0).SetString(turl)
mname := turl
if slash := strings.LastIndex(mname, "/"); slash >= 0 {
mname = mname[slash+1:]
var m proto.Message
var err error
if u.AnyResolver != nil {
m, err = u.AnyResolver.Resolve(turl)
} else {
m, err = defaultResolveAny(turl)
}
mt := proto.MessageType(mname)
if mt == nil {
return fmt.Errorf("unknown message type %q", mname)
if err != nil {
return err
}
m := reflect.New(mt.Elem()).Interface().(proto.Message)
if _, ok := m.(isWkt); ok {
val, ok := jsonFields["value"]
if !ok {
return errors.New("Any JSON doesn't have 'value'")
}
if err := u.unmarshalValue(reflect.ValueOf(m).Elem(), val, nil); err != nil {
return fmt.Errorf("can't unmarshal Any's WKT: %v", err)
if err = u.unmarshalValue(reflect.ValueOf(m).Elem(), *val, nil); err != nil {
return fmt.Errorf("can't unmarshal Any nested proto %T: %v", m, err)
}
} else {
delete(jsonFields, "@type")
nestedProto, err := json.Marshal(jsonFields)
if err != nil {
return fmt.Errorf("can't generate JSON for Any's nested proto to be unmarshaled: %v", err)
nestedProto, uerr := json.Marshal(jsonFields)
if uerr != nil {
return fmt.Errorf("can't generate JSON for Any's nested proto to be unmarshaled: %v", uerr)
}
if err = u.unmarshalValue(reflect.ValueOf(m).Elem(), nestedProto, nil); err != nil {
return fmt.Errorf("can't unmarshal nested Any proto: %v", err)
return fmt.Errorf("can't unmarshal Any nested proto %T: %v", m, err)
}
}
b, err := proto.Marshal(m)
if err != nil {
return fmt.Errorf("can't marshal proto into Any.Value: %v", err)
return fmt.Errorf("can't marshal proto %T into Any.Value: %v", m, err)
}
target.Field(1).SetBytes(b)
return nil
case "Duration":
ivStr := string(inputValue)
if ivStr == "null" {
target.Field(0).SetInt(0)
target.Field(1).SetInt(0)
return nil
}
unq, err := strconv.Unquote(ivStr)
unq, err := strconv.Unquote(string(inputValue))
if err != nil {
return err
}
d, err := time.ParseDuration(unq)
if err != nil {
return fmt.Errorf("bad Duration: %v", err)
}
ns := d.Nanoseconds()
s := ns / 1e9
ns %= 1e9
@@ -773,29 +853,20 @@ func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMe
target.Field(1).SetInt(ns)
return nil
case "Timestamp":
ivStr := string(inputValue)
if ivStr == "null" {
target.Field(0).SetInt(0)
target.Field(1).SetInt(0)
return nil
}
unq, err := strconv.Unquote(ivStr)
unq, err := strconv.Unquote(string(inputValue))
if err != nil {
return err
}
t, err := time.Parse(time.RFC3339Nano, unq)
if err != nil {
return fmt.Errorf("bad Timestamp: %v", err)
}
target.Field(0).SetInt(int64(t.Unix()))
target.Field(0).SetInt(t.Unix())
target.Field(1).SetInt(int64(t.Nanosecond()))
return nil
case "Struct":
if string(inputValue) == "null" {
// Interpret a null struct as empty.
return nil
}
var m map[string]json.RawMessage
if err := json.Unmarshal(inputValue, &m); err != nil {
return fmt.Errorf("bad StructValue: %v", err)
@@ -810,14 +881,11 @@ func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMe
}
return nil
case "ListValue":
if string(inputValue) == "null" {
// Interpret a null ListValue as empty.
return nil
}
var s []json.RawMessage
if err := json.Unmarshal(inputValue, &s); err != nil {
return fmt.Errorf("bad ListValue: %v", err)
}
target.Field(0).Set(reflect.ValueOf(make([]*types.Value, len(s), len(s))))
for i, sv := range s {
if err := u.unmarshalValue(target.Field(0).Index(i), sv, prop); err != nil {
@@ -899,7 +967,7 @@ func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMe
// Handle nested messages.
if targetType.Kind() == reflect.Struct {
if target.CanAddr() {
if prop != nil && len(prop.CustomType) > 0 && target.CanAddr() {
if m, ok := target.Addr().Interface().(interface {
UnmarshalJSON([]byte) error
}); ok {
@@ -1026,11 +1094,13 @@ func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMe
if err := json.Unmarshal(inputValue, &slc); err != nil {
return err
}
len := len(slc)
target.Set(reflect.MakeSlice(targetType, len, len))
for i := 0; i < len; i++ {
if err := u.unmarshalValue(target.Index(i), slc[i], prop); err != nil {
return err
if slc != nil {
l := len(slc)
target.Set(reflect.MakeSlice(targetType, l, l))
for i := 0; i < l; i++ {
if err := u.unmarshalValue(target.Index(i), slc[i], prop); err != nil {
return err
}
}
}
return nil
@@ -1042,37 +1112,39 @@ func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMe
if err := json.Unmarshal(inputValue, &mp); err != nil {
return err
}
target.Set(reflect.MakeMap(targetType))
var keyprop, valprop *proto.Properties
if prop != nil {
// These could still be nil if the protobuf metadata is broken somehow.
// TODO: This won't work because the fields are unexported.
// We should probably just reparse them.
//keyprop, valprop = prop.mkeyprop, prop.mvalprop
}
for ks, raw := range mp {
// Unmarshal map key. The core json library already decoded the key into a
// string, so we handle that specially. Other types were quoted post-serialization.
var k reflect.Value
if targetType.Key().Kind() == reflect.String {
k = reflect.ValueOf(ks)
} else {
k = reflect.New(targetType.Key()).Elem()
if err := u.unmarshalValue(k, json.RawMessage(ks), keyprop); err != nil {
if mp != nil {
target.Set(reflect.MakeMap(targetType))
var keyprop, valprop *proto.Properties
if prop != nil {
// These could still be nil if the protobuf metadata is broken somehow.
// TODO: This won't work because the fields are unexported.
// We should probably just reparse them.
//keyprop, valprop = prop.mkeyprop, prop.mvalprop
}
for ks, raw := range mp {
// Unmarshal map key. The core json library already decoded the key into a
// string, so we handle that specially. Other types were quoted post-serialization.
var k reflect.Value
if targetType.Key().Kind() == reflect.String {
k = reflect.ValueOf(ks)
} else {
k = reflect.New(targetType.Key()).Elem()
if err := u.unmarshalValue(k, json.RawMessage(ks), keyprop); err != nil {
return err
}
}
if !k.Type().AssignableTo(targetType.Key()) {
k = k.Convert(targetType.Key())
}
// Unmarshal map value.
v := reflect.New(targetType.Elem()).Elem()
if err := u.unmarshalValue(v, raw, valprop); err != nil {
return err
}
target.SetMapIndex(k, v)
}
if !k.Type().AssignableTo(targetType.Key()) {
k = k.Convert(targetType.Key())
}
// Unmarshal map value.
v := reflect.New(targetType.Elem()).Elem()
if err := u.unmarshalValue(v, raw, valprop); err != nil {
return err
}
target.SetMapIndex(k, v)
}
return nil
}
@@ -1084,6 +1156,15 @@ func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMe
inputValue = inputValue[1 : len(inputValue)-1]
}
// Non-finite numbers can be encoded as strings.
isFloat := targetType.Kind() == reflect.Float32 || targetType.Kind() == reflect.Float64
if isFloat {
if num, ok := nonFinite[string(inputValue)]; ok {
target.SetFloat(num)
return nil
}
}
// Use the encoding/json for parsing other value types.
return json.Unmarshal(inputValue, target.Addr().Interface())
}

686
vendor/github.com/gogo/protobuf/jsonpb/jsonpb_test.go generated vendored
View File

@@ -1,686 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2015 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package jsonpb
import (
"bytes"
"encoding/json"
"io"
"reflect"
"strings"
"testing"
pb "github.com/gogo/protobuf/jsonpb/jsonpb_test_proto"
"github.com/gogo/protobuf/proto"
proto3pb "github.com/gogo/protobuf/proto/proto3_proto"
"github.com/gogo/protobuf/types"
)
var (
marshaler = Marshaler{}
marshalerAllOptions = Marshaler{
Indent: " ",
}
simpleObject = &pb.Simple{
OInt32: proto.Int32(-32),
OInt64: proto.Int64(-6400000000),
OUint32: proto.Uint32(32),
OUint64: proto.Uint64(6400000000),
OSint32: proto.Int32(-13),
OSint64: proto.Int64(-2600000000),
OFloat: proto.Float32(3.14),
ODouble: proto.Float64(6.02214179e23),
OBool: proto.Bool(true),
OString: proto.String("hello \"there\""),
OBytes: []byte("beep boop"),
OCastBytes: pb.Bytes("wow"),
}
simpleObjectJSON = `{` +
`"oBool":true,` +
`"oInt32":-32,` +
`"oInt64":"-6400000000",` +
`"oUint32":32,` +
`"oUint64":"6400000000",` +
`"oSint32":-13,` +
`"oSint64":"-2600000000",` +
`"oFloat":3.14,` +
`"oDouble":6.02214179e+23,` +
`"oString":"hello \"there\"",` +
`"oBytes":"YmVlcCBib29w",` +
`"oCastBytes":"d293"` +
`}`
simpleObjectPrettyJSON = `{
"oBool": true,
"oInt32": -32,
"oInt64": "-6400000000",
"oUint32": 32,
"oUint64": "6400000000",
"oSint32": -13,
"oSint64": "-2600000000",
"oFloat": 3.14,
"oDouble": 6.02214179e+23,
"oString": "hello \"there\"",
"oBytes": "YmVlcCBib29w",
"oCastBytes": "d293"
}`
repeatsObject = &pb.Repeats{
RBool: []bool{true, false, true},
RInt32: []int32{-3, -4, -5},
RInt64: []int64{-123456789, -987654321},
RUint32: []uint32{1, 2, 3},
RUint64: []uint64{6789012345, 3456789012},
RSint32: []int32{-1, -2, -3},
RSint64: []int64{-6789012345, -3456789012},
RFloat: []float32{3.14, 6.28},
RDouble: []float64{299792458 * 1e20, 6.62606957e-34},
RString: []string{"happy", "days"},
RBytes: [][]byte{[]byte("skittles"), []byte("m&m's")},
}
repeatsObjectJSON = `{` +
`"rBool":[true,false,true],` +
`"rInt32":[-3,-4,-5],` +
`"rInt64":["-123456789","-987654321"],` +
`"rUint32":[1,2,3],` +
`"rUint64":["6789012345","3456789012"],` +
`"rSint32":[-1,-2,-3],` +
`"rSint64":["-6789012345","-3456789012"],` +
`"rFloat":[3.14,6.28],` +
`"rDouble":[2.99792458e+28,6.62606957e-34],` +
`"rString":["happy","days"],` +
`"rBytes":["c2tpdHRsZXM=","bSZtJ3M="]` +
`}`
repeatsObjectPrettyJSON = `{
"rBool": [
true,
false,
true
],
"rInt32": [
-3,
-4,
-5
],
"rInt64": [
"-123456789",
"-987654321"
],
"rUint32": [
1,
2,
3
],
"rUint64": [
"6789012345",
"3456789012"
],
"rSint32": [
-1,
-2,
-3
],
"rSint64": [
"-6789012345",
"-3456789012"
],
"rFloat": [
3.14,
6.28
],
"rDouble": [
2.99792458e+28,
6.62606957e-34
],
"rString": [
"happy",
"days"
],
"rBytes": [
"c2tpdHRsZXM=",
"bSZtJ3M="
]
}`
innerSimple = &pb.Simple{OInt32: proto.Int32(-32)}
innerSimple2 = &pb.Simple{OInt64: proto.Int64(25)}
innerRepeats = &pb.Repeats{RString: []string{"roses", "red"}}
innerRepeats2 = &pb.Repeats{RString: []string{"violets", "blue"}}
complexObject = &pb.Widget{
Color: pb.Widget_GREEN.Enum(),
RColor: []pb.Widget_Color{pb.Widget_RED, pb.Widget_GREEN, pb.Widget_BLUE},
Simple: innerSimple,
RSimple: []*pb.Simple{innerSimple, innerSimple2},
Repeats: innerRepeats,
RRepeats: []*pb.Repeats{innerRepeats, innerRepeats2},
}
complexObjectJSON = `{"color":"GREEN",` +
`"rColor":["RED","GREEN","BLUE"],` +
`"simple":{"oInt32":-32},` +
`"rSimple":[{"oInt32":-32},{"oInt64":"25"}],` +
`"repeats":{"rString":["roses","red"]},` +
`"rRepeats":[{"rString":["roses","red"]},{"rString":["violets","blue"]}]` +
`}`
complexObjectPrettyJSON = `{
"color": "GREEN",
"rColor": [
"RED",
"GREEN",
"BLUE"
],
"simple": {
"oInt32": -32
},
"rSimple": [
{
"oInt32": -32
},
{
"oInt64": "25"
}
],
"repeats": {
"rString": [
"roses",
"red"
]
},
"rRepeats": [
{
"rString": [
"roses",
"red"
]
},
{
"rString": [
"violets",
"blue"
]
}
]
}`
colorPrettyJSON = `{
"color": 2
}`
colorListPrettyJSON = `{
"color": 1000,
"rColor": [
"RED"
]
}`
nummyPrettyJSON = `{
"nummy": {
"1": 2,
"3": 4
}
}`
objjyPrettyJSON = `{
"objjy": {
"1": {
"dub": 1
}
}
}`
realNumber = &pb.Real{Value: proto.Float64(3.14159265359)}
realNumberName = "Pi"
complexNumber = &pb.Complex{Imaginary: proto.Float64(0.5772156649)}
realNumberJSON = `{` +
`"value":3.14159265359,` +
`"[jsonpb.Complex.real_extension]":{"imaginary":0.5772156649},` +
`"[jsonpb.name]":"Pi"` +
`}`
anySimple = &pb.KnownTypes{
An: &types.Any{
TypeUrl: "something.example.com/jsonpb.Simple",
Value: []byte{
// &pb.Simple{OBool:true}
1 << 3, 1,
},
},
}
anySimpleJSON = `{"an":{"@type":"something.example.com/jsonpb.Simple","oBool":true}}`
anySimplePrettyJSON = `{
"an": {
"@type": "something.example.com/jsonpb.Simple",
"oBool": true
}
}`
anyWellKnown = &pb.KnownTypes{
An: &types.Any{
TypeUrl: "type.googleapis.com/google.protobuf.Duration",
Value: []byte{
// &durpb.Duration{Seconds: 1, Nanos: 212000000 }
1 << 3, 1, // seconds
2 << 3, 0x80, 0xba, 0x8b, 0x65, // nanos
},
},
}
anyWellKnownJSON = `{"an":{"@type":"type.googleapis.com/google.protobuf.Duration","value":"1.212s"}}`
anyWellKnownPrettyJSON = `{
"an": {
"@type": "type.googleapis.com/google.protobuf.Duration",
"value": "1.212s"
}
}`
)
func init() {
if err := proto.SetExtension(realNumber, pb.E_Name, &realNumberName); err != nil {
panic(err)
}
if err := proto.SetExtension(realNumber, pb.E_Complex_RealExtension, complexNumber); err != nil {
panic(err)
}
}
var marshalingTests = []struct {
desc string
marshaler Marshaler
pb proto.Message
json string
}{
{"simple flat object", marshaler, simpleObject, simpleObjectJSON},
{"simple pretty object", marshalerAllOptions, simpleObject, simpleObjectPrettyJSON},
{"repeated fields flat object", marshaler, repeatsObject, repeatsObjectJSON},
{"repeated fields pretty object", marshalerAllOptions, repeatsObject, repeatsObjectPrettyJSON},
{"nested message/enum flat object", marshaler, complexObject, complexObjectJSON},
{"nested message/enum pretty object", marshalerAllOptions, complexObject, complexObjectPrettyJSON},
{"enum-string flat object", Marshaler{},
&pb.Widget{Color: pb.Widget_BLUE.Enum()}, `{"color":"BLUE"}`},
{"enum-value pretty object", Marshaler{EnumsAsInts: true, Indent: " "},
&pb.Widget{Color: pb.Widget_BLUE.Enum()}, colorPrettyJSON},
{"unknown enum value object", marshalerAllOptions,
&pb.Widget{Color: pb.Widget_Color(1000).Enum(), RColor: []pb.Widget_Color{pb.Widget_RED}}, colorListPrettyJSON},
{"repeated proto3 enum", Marshaler{},
&proto3pb.Message{RFunny: []proto3pb.Message_Humour{
proto3pb.Message_PUNS,
proto3pb.Message_SLAPSTICK,
}},
`{"rFunny":["PUNS","SLAPSTICK"]}`},
{"repeated proto3 enum as int", Marshaler{EnumsAsInts: true},
&proto3pb.Message{RFunny: []proto3pb.Message_Humour{
proto3pb.Message_PUNS,
proto3pb.Message_SLAPSTICK,
}},
`{"rFunny":[1,2]}`},
{"empty value", marshaler, &pb.Simple3{}, `{}`},
{"empty value emitted", Marshaler{EmitDefaults: true}, &pb.Simple3{}, `{"dub":0}`},
{"empty repeated emitted", Marshaler{EmitDefaults: true}, &pb.SimpleSlice3{}, `{"slices":[]}`},
{"empty map emitted", Marshaler{EmitDefaults: true}, &pb.SimpleMap3{}, `{"stringy":{}}`},
{"nested struct null", Marshaler{EmitDefaults: true}, &pb.SimpleNull3{}, `{"simple":null}`},
{"map<int64, int32>", marshaler, &pb.Mappy{Nummy: map[int64]int32{1: 2, 3: 4}}, `{"nummy":{"1":2,"3":4}}`},
{"map<int64, int32>", marshalerAllOptions, &pb.Mappy{Nummy: map[int64]int32{1: 2, 3: 4}}, nummyPrettyJSON},
{"map<string, string>", marshaler,
&pb.Mappy{Strry: map[string]string{`"one"`: "two", "three": "four"}},
`{"strry":{"\"one\"":"two","three":"four"}}`},
{"map<int32, Object>", marshaler,
&pb.Mappy{Objjy: map[int32]*pb.Simple3{1: {Dub: 1}}}, `{"objjy":{"1":{"dub":1}}}`},
{"map<int32, Object>", marshalerAllOptions,
&pb.Mappy{Objjy: map[int32]*pb.Simple3{1: {Dub: 1}}}, objjyPrettyJSON},
{"map<int64, string>", marshaler, &pb.Mappy{Buggy: map[int64]string{1234: "yup"}},
`{"buggy":{"1234":"yup"}}`},
{"map<bool, bool>", marshaler, &pb.Mappy{Booly: map[bool]bool{false: true}}, `{"booly":{"false":true}}`},
// TODO: This is broken.
//{"map<string, enum>", marshaler, &pb.Mappy{Enumy: map[string]pb.Numeral{"XIV": pb.Numeral_ROMAN}}, `{"enumy":{"XIV":"ROMAN"}`},
{"map<string, enum as int>", Marshaler{EnumsAsInts: true}, &pb.Mappy{Enumy: map[string]pb.Numeral{"XIV": pb.Numeral_ROMAN}}, `{"enumy":{"XIV":2}}`},
{"map<int32, bool>", marshaler, &pb.Mappy{S32Booly: map[int32]bool{1: true, 3: false, 10: true, 12: false}}, `{"s32booly":{"1":true,"3":false,"10":true,"12":false}}`},
{"map<int64, bool>", marshaler, &pb.Mappy{S64Booly: map[int64]bool{1: true, 3: false, 10: true, 12: false}}, `{"s64booly":{"1":true,"3":false,"10":true,"12":false}}`},
{"map<uint32, bool>", marshaler, &pb.Mappy{U32Booly: map[uint32]bool{1: true, 3: false, 10: true, 12: false}}, `{"u32booly":{"1":true,"3":false,"10":true,"12":false}}`},
{"map<uint64, bool>", marshaler, &pb.Mappy{U64Booly: map[uint64]bool{1: true, 3: false, 10: true, 12: false}}, `{"u64booly":{"1":true,"3":false,"10":true,"12":false}}`},
{"proto2 map<int64, string>", marshaler, &pb.Maps{MInt64Str: map[int64]string{213: "cat"}},
`{"mInt64Str":{"213":"cat"}}`},
{"proto2 map<bool, Object>", marshaler,
&pb.Maps{MBoolSimple: map[bool]*pb.Simple{true: {OInt32: proto.Int32(1)}}},
`{"mBoolSimple":{"true":{"oInt32":1}}}`},
{"oneof, not set", marshaler, &pb.MsgWithOneof{}, `{}`},
{"oneof, set", marshaler, &pb.MsgWithOneof{Union: &pb.MsgWithOneof_Title{Title: "Grand Poobah"}}, `{"title":"Grand Poobah"}`},
{"force orig_name", Marshaler{OrigName: true}, &pb.Simple{OInt32: proto.Int32(4)},
`{"o_int32":4}`},
{"proto2 extension", marshaler, realNumber, realNumberJSON},
{"Any with message", marshaler, anySimple, anySimpleJSON},
{"Any with message and indent", marshalerAllOptions, anySimple, anySimplePrettyJSON},
{"Any with WKT", marshaler, anyWellKnown, anyWellKnownJSON},
{"Any with WKT and indent", marshalerAllOptions, anyWellKnown, anyWellKnownPrettyJSON},
{"Duration", marshaler, &pb.KnownTypes{Dur: &types.Duration{Seconds: 3}}, `{"dur":"3.000s"}`},
{"Struct", marshaler, &pb.KnownTypes{St: &types.Struct{
Fields: map[string]*types.Value{
"one": {Kind: &types.Value_StringValue{StringValue: "loneliest number"}},
"two": {Kind: &types.Value_NullValue{NullValue: types.NULL_VALUE}},
},
}}, `{"st":{"one":"loneliest number","two":null}}`},
{"empty ListValue", marshaler, &pb.KnownTypes{Lv: &types.ListValue{}}, `{"lv":[]}`},
{"basic ListValue", marshaler, &pb.KnownTypes{Lv: &types.ListValue{Values: []*types.Value{
{Kind: &types.Value_StringValue{StringValue: "x"}},
{Kind: &types.Value_NullValue{}},
{Kind: &types.Value_NumberValue{NumberValue: 3}},
{Kind: &types.Value_BoolValue{BoolValue: true}},
}}}, `{"lv":["x",null,3,true]}`},
{"Timestamp", marshaler, &pb.KnownTypes{Ts: &types.Timestamp{Seconds: 14e8, Nanos: 21e6}}, `{"ts":"2014-05-13T16:53:20.021Z"}`},
{"number Value", marshaler, &pb.KnownTypes{Val: &types.Value{Kind: &types.Value_NumberValue{NumberValue: 1}}}, `{"val":1}`},
{"null Value", marshaler, &pb.KnownTypes{Val: &types.Value{Kind: &types.Value_NullValue{NullValue: types.NULL_VALUE}}}, `{"val":null}`},
{"string number value", marshaler, &pb.KnownTypes{Val: &types.Value{Kind: &types.Value_StringValue{StringValue: "9223372036854775807"}}}, `{"val":"9223372036854775807"}`},
{"list of lists Value", marshaler, &pb.KnownTypes{Val: &types.Value{
Kind: &types.Value_ListValue{ListValue: &types.ListValue{
Values: []*types.Value{
{Kind: &types.Value_StringValue{StringValue: "x"}},
{Kind: &types.Value_ListValue{ListValue: &types.ListValue{
Values: []*types.Value{
{Kind: &types.Value_ListValue{ListValue: &types.ListValue{
Values: []*types.Value{{Kind: &types.Value_StringValue{StringValue: "y"}}},
}}},
{Kind: &types.Value_StringValue{StringValue: "z"}},
},
}}},
},
}},
}}, `{"val":["x",[["y"],"z"]]}`},
{"DoubleValue", marshaler, &pb.KnownTypes{Dbl: &types.DoubleValue{Value: 1.2}}, `{"dbl":1.2}`},
{"FloatValue", marshaler, &pb.KnownTypes{Flt: &types.FloatValue{Value: 1.2}}, `{"flt":1.2}`},
{"Int64Value", marshaler, &pb.KnownTypes{I64: &types.Int64Value{Value: -3}}, `{"i64":"-3"}`},
{"UInt64Value", marshaler, &pb.KnownTypes{U64: &types.UInt64Value{Value: 3}}, `{"u64":"3"}`},
{"Int32Value", marshaler, &pb.KnownTypes{I32: &types.Int32Value{Value: -4}}, `{"i32":-4}`},
{"UInt32Value", marshaler, &pb.KnownTypes{U32: &types.UInt32Value{Value: 4}}, `{"u32":4}`},
{"BoolValue", marshaler, &pb.KnownTypes{Bool: &types.BoolValue{Value: true}}, `{"bool":true}`},
{"StringValue", marshaler, &pb.KnownTypes{Str: &types.StringValue{Value: "plush"}}, `{"str":"plush"}`},
{"BytesValue", marshaler, &pb.KnownTypes{Bytes: &types.BytesValue{Value: []byte("wow")}}, `{"bytes":"d293"}`},
}
func TestMarshaling(t *testing.T) {
for _, tt := range marshalingTests {
json, err := tt.marshaler.MarshalToString(tt.pb)
if err != nil {
t.Errorf("%s: marshaling error: %v", tt.desc, err)
} else if tt.json != json {
t.Errorf("%s: got [%v] want [%v]", tt.desc, json, tt.json)
}
}
}
func TestMarshalingWithJSONPBMarshaler(t *testing.T) {
rawJson := `{ "foo": "bar", "baz": [0, 1, 2, 3] }`
msg := dynamicMessage{rawJson: rawJson}
str, err := new(Marshaler).MarshalToString(&msg)
if err != nil {
t.Errorf("an unexpected error occurred when marshalling JSONPBMarshaler: %v", err)
}
if str != rawJson {
t.Errorf("marshalling JSON produced incorrect output: got %s, wanted %s", str, rawJson)
}
}
var unmarshalingTests = []struct {
desc string
unmarshaler Unmarshaler
json string
pb proto.Message
}{
{"simple flat object", Unmarshaler{}, simpleObjectJSON, simpleObject},
{"simple pretty object", Unmarshaler{}, simpleObjectPrettyJSON, simpleObject},
{"repeated fields flat object", Unmarshaler{}, repeatsObjectJSON, repeatsObject},
{"repeated fields pretty object", Unmarshaler{}, repeatsObjectPrettyJSON, repeatsObject},
{"nested message/enum flat object", Unmarshaler{}, complexObjectJSON, complexObject},
{"nested message/enum pretty object", Unmarshaler{}, complexObjectPrettyJSON, complexObject},
{"enum-string object", Unmarshaler{}, `{"color":"BLUE"}`, &pb.Widget{Color: pb.Widget_BLUE.Enum()}},
{"enum-value object", Unmarshaler{}, "{\n \"color\": 2\n}", &pb.Widget{Color: pb.Widget_BLUE.Enum()}},
{"unknown field with allowed option", Unmarshaler{AllowUnknownFields: true}, `{"unknown": "foo"}`, new(pb.Simple)},
{"proto3 enum string", Unmarshaler{}, `{"hilarity":"PUNS"}`, &proto3pb.Message{Hilarity: proto3pb.Message_PUNS}},
{"proto3 enum value", Unmarshaler{}, `{"hilarity":1}`, &proto3pb.Message{Hilarity: proto3pb.Message_PUNS}},
{"unknown enum value object",
Unmarshaler{},
"{\n \"color\": 1000,\n \"r_color\": [\n \"RED\"\n ]\n}",
&pb.Widget{Color: pb.Widget_Color(1000).Enum(), RColor: []pb.Widget_Color{pb.Widget_RED}}},
{"repeated proto3 enum", Unmarshaler{}, `{"rFunny":["PUNS","SLAPSTICK"]}`,
&proto3pb.Message{RFunny: []proto3pb.Message_Humour{
proto3pb.Message_PUNS,
proto3pb.Message_SLAPSTICK,
}}},
{"repeated proto3 enum as int", Unmarshaler{}, `{"rFunny":[1,2]}`,
&proto3pb.Message{RFunny: []proto3pb.Message_Humour{
proto3pb.Message_PUNS,
proto3pb.Message_SLAPSTICK,
}}},
{"repeated proto3 enum as mix of strings and ints", Unmarshaler{}, `{"rFunny":["PUNS",2]}`,
&proto3pb.Message{RFunny: []proto3pb.Message_Humour{
proto3pb.Message_PUNS,
proto3pb.Message_SLAPSTICK,
}}},
{"unquoted int64 object", Unmarshaler{}, `{"oInt64":-314}`, &pb.Simple{OInt64: proto.Int64(-314)}},
{"unquoted uint64 object", Unmarshaler{}, `{"oUint64":123}`, &pb.Simple{OUint64: proto.Uint64(123)}},
{"map<int64, int32>", Unmarshaler{}, `{"nummy":{"1":2,"3":4}}`, &pb.Mappy{Nummy: map[int64]int32{1: 2, 3: 4}}},
{"map<string, string>", Unmarshaler{}, `{"strry":{"\"one\"":"two","three":"four"}}`, &pb.Mappy{Strry: map[string]string{`"one"`: "two", "three": "four"}}},
{"map<int32, Object>", Unmarshaler{}, `{"objjy":{"1":{"dub":1}}}`, &pb.Mappy{Objjy: map[int32]*pb.Simple3{1: {Dub: 1}}}},
{"proto2 extension", Unmarshaler{}, realNumberJSON, realNumber},
// TODO does not work with go version 1.7, but works with go version 1.8 {"Any with message", Unmarshaler{}, anySimpleJSON, anySimple},
// TODO does not work with go version 1.7, but works with go version 1.8 {"Any with message and indent", Unmarshaler{}, anySimplePrettyJSON, anySimple},
{"Any with WKT", Unmarshaler{}, anyWellKnownJSON, anyWellKnown},
{"Any with WKT and indent", Unmarshaler{}, anyWellKnownPrettyJSON, anyWellKnown},
// TODO: This is broken.
//{"map<string, enum>", Unmarshaler{}, `{"enumy":{"XIV":"ROMAN"}`, &pb.Mappy{Enumy: map[string]pb.Numeral{"XIV": pb.Numeral_ROMAN}}},
{"map<string, enum as int>", Unmarshaler{}, `{"enumy":{"XIV":2}}`, &pb.Mappy{Enumy: map[string]pb.Numeral{"XIV": pb.Numeral_ROMAN}}},
{"oneof", Unmarshaler{}, `{"salary":31000}`, &pb.MsgWithOneof{Union: &pb.MsgWithOneof_Salary{Salary: 31000}}},
{"oneof spec name", Unmarshaler{}, `{"Country":"Australia"}`, &pb.MsgWithOneof{Union: &pb.MsgWithOneof_Country{Country: "Australia"}}},
{"oneof orig_name", Unmarshaler{}, `{"Country":"Australia"}`, &pb.MsgWithOneof{Union: &pb.MsgWithOneof_Country{Country: "Australia"}}},
{"oneof spec name2", Unmarshaler{}, `{"homeAddress":"Australia"}`, &pb.MsgWithOneof{Union: &pb.MsgWithOneof_HomeAddress{HomeAddress: "Australia"}}},
{"oneof orig_name2", Unmarshaler{}, `{"home_address":"Australia"}`, &pb.MsgWithOneof{Union: &pb.MsgWithOneof_HomeAddress{HomeAddress: "Australia"}}},
{"orig_name input", Unmarshaler{}, `{"o_bool":true}`, &pb.Simple{OBool: proto.Bool(true)}},
{"camelName input", Unmarshaler{}, `{"oBool":true}`, &pb.Simple{OBool: proto.Bool(true)}},
{"Duration", Unmarshaler{}, `{"dur":"3.000s"}`, &pb.KnownTypes{Dur: &types.Duration{Seconds: 3}}},
{"null Duration", Unmarshaler{}, `{"dur":null}`, &pb.KnownTypes{Dur: &types.Duration{Seconds: 0}}},
{"Timestamp", Unmarshaler{}, `{"ts":"2014-05-13T16:53:20.021Z"}`, &pb.KnownTypes{Ts: &types.Timestamp{Seconds: 14e8, Nanos: 21e6}}},
{"PreEpochTimestamp", Unmarshaler{}, `{"ts":"1969-12-31T23:59:58.999999995Z"}`, &pb.KnownTypes{Ts: &types.Timestamp{Seconds: -2, Nanos: 999999995}}},
{"ZeroTimeTimestamp", Unmarshaler{}, `{"ts":"0001-01-01T00:00:00Z"}`, &pb.KnownTypes{Ts: &types.Timestamp{Seconds: -62135596800, Nanos: 0}}},
{"null Timestamp", Unmarshaler{}, `{"ts":null}`, &pb.KnownTypes{Ts: &types.Timestamp{Seconds: 0, Nanos: 0}}},
{"null Struct", Unmarshaler{}, `{"st": null}`, &pb.KnownTypes{St: &types.Struct{}}},
{"empty Struct", Unmarshaler{}, `{"st": {}}`, &pb.KnownTypes{St: &types.Struct{}}},
{"basic Struct", Unmarshaler{}, `{"st": {"a": "x", "b": null, "c": 3, "d": true}}`, &pb.KnownTypes{St: &types.Struct{Fields: map[string]*types.Value{
"a": {Kind: &types.Value_StringValue{StringValue: "x"}},
"b": {Kind: &types.Value_NullValue{}},
"c": {Kind: &types.Value_NumberValue{NumberValue: 3}},
"d": {Kind: &types.Value_BoolValue{BoolValue: true}},
}}}},
{"nested Struct", Unmarshaler{}, `{"st": {"a": {"b": 1, "c": [{"d": true}, "f"]}}}`, &pb.KnownTypes{St: &types.Struct{Fields: map[string]*types.Value{
"a": {Kind: &types.Value_StructValue{StructValue: &types.Struct{Fields: map[string]*types.Value{
"b": {Kind: &types.Value_NumberValue{NumberValue: 1}},
"c": {Kind: &types.Value_ListValue{ListValue: &types.ListValue{Values: []*types.Value{
{Kind: &types.Value_StructValue{StructValue: &types.Struct{Fields: map[string]*types.Value{"d": {Kind: &types.Value_BoolValue{BoolValue: true}}}}}},
{Kind: &types.Value_StringValue{StringValue: "f"}},
}}}},
}}}},
}}}},
{"null ListValue", Unmarshaler{}, `{"lv": null}`, &pb.KnownTypes{Lv: &types.ListValue{}}},
{"empty ListValue", Unmarshaler{}, `{"lv": []}`, &pb.KnownTypes{Lv: &types.ListValue{}}},
{"basic ListValue", Unmarshaler{}, `{"lv": ["x", null, 3, true]}`, &pb.KnownTypes{Lv: &types.ListValue{Values: []*types.Value{
{Kind: &types.Value_StringValue{StringValue: "x"}},
{Kind: &types.Value_NullValue{}},
{Kind: &types.Value_NumberValue{NumberValue: 3}},
{Kind: &types.Value_BoolValue{BoolValue: true}},
}}}},
{"number Value", Unmarshaler{}, `{"val":1}`, &pb.KnownTypes{Val: &types.Value{Kind: &types.Value_NumberValue{NumberValue: 1}}}},
{"null Value", Unmarshaler{}, `{"val":null}`, &pb.KnownTypes{Val: &types.Value{Kind: &types.Value_NullValue{NullValue: types.NULL_VALUE}}}},
{"bool Value", Unmarshaler{}, `{"val":true}`, &pb.KnownTypes{Val: &types.Value{Kind: &types.Value_BoolValue{BoolValue: true}}}},
{"string Value", Unmarshaler{}, `{"val":"x"}`, &pb.KnownTypes{Val: &types.Value{Kind: &types.Value_StringValue{StringValue: "x"}}}},
{"string number value", Unmarshaler{}, `{"val":"9223372036854775807"}`, &pb.KnownTypes{Val: &types.Value{Kind: &types.Value_StringValue{StringValue: "9223372036854775807"}}}},
{"list of lists Value", Unmarshaler{}, `{"val":["x", [["y"], "z"]]}`, &pb.KnownTypes{Val: &types.Value{
Kind: &types.Value_ListValue{ListValue: &types.ListValue{
Values: []*types.Value{
{Kind: &types.Value_StringValue{StringValue: "x"}},
{Kind: &types.Value_ListValue{ListValue: &types.ListValue{
Values: []*types.Value{
{Kind: &types.Value_ListValue{ListValue: &types.ListValue{
Values: []*types.Value{{Kind: &types.Value_StringValue{StringValue: "y"}}},
}}},
{Kind: &types.Value_StringValue{StringValue: "z"}},
},
}}},
},
}}}}},
{"DoubleValue", Unmarshaler{}, `{"dbl":1.2}`, &pb.KnownTypes{Dbl: &types.DoubleValue{Value: 1.2}}},
{"FloatValue", Unmarshaler{}, `{"flt":1.2}`, &pb.KnownTypes{Flt: &types.FloatValue{Value: 1.2}}},
{"Int64Value", Unmarshaler{}, `{"i64":"-3"}`, &pb.KnownTypes{I64: &types.Int64Value{Value: -3}}},
{"UInt64Value", Unmarshaler{}, `{"u64":"3"}`, &pb.KnownTypes{U64: &types.UInt64Value{Value: 3}}},
{"Int32Value", Unmarshaler{}, `{"i32":-4}`, &pb.KnownTypes{I32: &types.Int32Value{Value: -4}}},
{"UInt32Value", Unmarshaler{}, `{"u32":4}`, &pb.KnownTypes{U32: &types.UInt32Value{Value: 4}}},
{"BoolValue", Unmarshaler{}, `{"bool":true}`, &pb.KnownTypes{Bool: &types.BoolValue{Value: true}}},
{"StringValue", Unmarshaler{}, `{"str":"plush"}`, &pb.KnownTypes{Str: &types.StringValue{Value: "plush"}}},
{"BytesValue", Unmarshaler{}, `{"bytes":"d293"}`, &pb.KnownTypes{Bytes: &types.BytesValue{Value: []byte("wow")}}},
// `null` is also a permissible value. Let's just test one.
{"null DoubleValue", Unmarshaler{}, `{"dbl":null}`, &pb.KnownTypes{Dbl: &types.DoubleValue{}}},
}
func TestUnmarshaling(t *testing.T) {
for _, tt := range unmarshalingTests {
// Make a new instance of the type of our expected object.
p := reflect.New(reflect.TypeOf(tt.pb).Elem()).Interface().(proto.Message)
err := tt.unmarshaler.Unmarshal(strings.NewReader(tt.json), p)
if err != nil {
t.Errorf("%s: %v", tt.desc, err)
continue
}
// For easier diffs, compare text strings of the protos.
exp := proto.MarshalTextString(tt.pb)
act := proto.MarshalTextString(p)
if string(exp) != string(act) {
t.Errorf("%s: got [%s] want [%s]", tt.desc, act, exp)
}
}
}
func TestUnmarshalNext(t *testing.T) {
// We only need to check against a few, not all of them.
tests := unmarshalingTests[:5]
// Create a buffer with many concatenated JSON objects.
var b bytes.Buffer
for _, tt := range tests {
b.WriteString(tt.json)
}
dec := json.NewDecoder(&b)
for _, tt := range tests {
// Make a new instance of the type of our expected object.
p := reflect.New(reflect.TypeOf(tt.pb).Elem()).Interface().(proto.Message)
err := tt.unmarshaler.UnmarshalNext(dec, p)
if err != nil {
t.Errorf("%s: %v", tt.desc, err)
continue
}
// For easier diffs, compare text strings of the protos.
exp := proto.MarshalTextString(tt.pb)
act := proto.MarshalTextString(p)
if string(exp) != string(act) {
t.Errorf("%s: got [%s] want [%s]", tt.desc, act, exp)
}
}
p := &pb.Simple{}
err := new(Unmarshaler).UnmarshalNext(dec, p)
if err != io.EOF {
t.Errorf("eof: got %v, expected io.EOF", err)
}
}
var unmarshalingShouldError = []struct {
desc string
in string
pb proto.Message
}{
{"a value", "666", new(pb.Simple)},
{"gibberish", "{adskja123;l23=-=", new(pb.Simple)},
{"unknown field", `{"unknown": "foo"}`, new(pb.Simple)},
{"unknown enum name", `{"hilarity":"DAVE"}`, new(proto3pb.Message)},
}
func TestUnmarshalingBadInput(t *testing.T) {
for _, tt := range unmarshalingShouldError {
err := UnmarshalString(tt.in, tt.pb)
if err == nil {
t.Errorf("an error was expected when parsing %q instead of an object", tt.desc)
}
}
}
func TestUnmarshalWithJSONPBUnmarshaler(t *testing.T) {
rawJson := `{ "foo": "bar", "baz": [0, 1, 2, 3] }`
var msg dynamicMessage
err := Unmarshal(strings.NewReader(rawJson), &msg)
if err != nil {
t.Errorf("an unexpected error occurred when parsing into JSONPBUnmarshaler: %v", err)
}
if msg.rawJson != rawJson {
t.Errorf("message contents not set correctly after unmarshalling JSON: got %s, wanted %s", msg.rawJson, rawJson)
}
}
// dynamicMessage implements protobuf.Message but is not a normal generated message type.
// It provides implementations of JSONPBMarshaler and JSONPBUnmarshaler for JSON support.
type dynamicMessage struct {
rawJson string
}
func (m *dynamicMessage) Reset() {
m.rawJson = "{}"
}
func (m *dynamicMessage) String() string {
return m.rawJson
}
func (m *dynamicMessage) ProtoMessage() {
}
func (m *dynamicMessage) MarshalJSONPB(jm *Marshaler) ([]byte, error) {
return []byte(m.rawJson), nil
}
func (m *dynamicMessage) UnmarshalJSONPB(jum *Unmarshaler, json []byte) error {
m.rawJson = string(json)
return nil
}

33
vendor/github.com/gogo/protobuf/jsonpb/jsonpb_test_proto/Makefile generated vendored
View File

@@ -1,33 +0,0 @@
# Go support for Protocol Buffers - Google's data interchange format
#
# Copyright 2015 The Go Authors. All rights reserved.
# https://github.com/golang/protobuf
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
# * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
regenerate:
protoc-min-version --version="3.0.0" --gogo_out=Mgoogle/protobuf/any.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/duration.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/wrappers.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/struct.proto=github.com/gogo/protobuf/types:. *.proto -I . -I ../../ -I ../../protobuf/

1
vendor/github.com/gogo/protobuf/jsonpb/jsonpb_test_proto/more_test_objects.pb.go generated vendored
View File

@@ -15,6 +15,7 @@ It has these top-level messages:
SimpleNull3
Mappy
Simple
NonFinites
Repeats
Widget
Maps

69
vendor/github.com/gogo/protobuf/jsonpb/jsonpb_test_proto/more_test_objects.proto generated vendored
View File

@@ -1,69 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2015 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
syntax = "proto3";
package jsonpb;
message Simple3 {
double dub = 1;
}
message SimpleSlice3 {
repeated string slices = 1;
}
message SimpleMap3 {
map<string,string> stringy = 1;
}
message SimpleNull3 {
Simple3 simple = 1;
}
enum Numeral {
UNKNOWN = 0;
ARABIC = 1;
ROMAN = 2;
}
message Mappy {
map<int64, int32> nummy = 1;
map<string, string> strry = 2;
map<int32, Simple3> objjy = 3;
map<int64, string> buggy = 4;
map<bool, bool> booly = 5;
map<string, Numeral> enumy = 6;
map<int32, bool> s32booly = 7;
map<int64, bool> s64booly = 8;
map<uint32, bool> u32booly = 9;
map<uint64, bool> u64booly = 10;
}

226
vendor/github.com/gogo/protobuf/jsonpb/jsonpb_test_proto/test_objects.pb.go generated vendored
View File

@@ -12,7 +12,7 @@ import google_protobuf2 "github.com/gogo/protobuf/types"
import google_protobuf3 "github.com/gogo/protobuf/types"
import google_protobuf4 "github.com/gogo/protobuf/types"
// skipping weak import gogoproto "gogoproto"
// skipping weak import gogoproto "github.com/gogo/protobuf/gogoproto"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
@@ -54,7 +54,7 @@ func (x *Widget_Color) UnmarshalJSON(data []byte) error {
*x = Widget_Color(value)
return nil
}
func (Widget_Color) EnumDescriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{2, 0} }
func (Widget_Color) EnumDescriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{3, 0} }
// Test message for holding primitive types.
type Simple struct {
@@ -162,6 +162,64 @@ func (m *Simple) GetOCastBytes() Bytes {
return nil
}
// Test message for holding special non-finites primitives.
type NonFinites struct {
FNan *float32 `protobuf:"fixed32,1,opt,name=f_nan,json=fNan" json:"f_nan,omitempty"`
FPinf *float32 `protobuf:"fixed32,2,opt,name=f_pinf,json=fPinf" json:"f_pinf,omitempty"`
FNinf *float32 `protobuf:"fixed32,3,opt,name=f_ninf,json=fNinf" json:"f_ninf,omitempty"`
DNan *float64 `protobuf:"fixed64,4,opt,name=d_nan,json=dNan" json:"d_nan,omitempty"`
DPinf *float64 `protobuf:"fixed64,5,opt,name=d_pinf,json=dPinf" json:"d_pinf,omitempty"`
DNinf *float64 `protobuf:"fixed64,6,opt,name=d_ninf,json=dNinf" json:"d_ninf,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *NonFinites) Reset() { *m = NonFinites{} }
func (m *NonFinites) String() string { return proto.CompactTextString(m) }
func (*NonFinites) ProtoMessage() {}
func (*NonFinites) Descriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{1} }
func (m *NonFinites) GetFNan() float32 {
if m != nil && m.FNan != nil {
return *m.FNan
}
return 0
}
func (m *NonFinites) GetFPinf() float32 {
if m != nil && m.FPinf != nil {
return *m.FPinf
}
return 0
}
func (m *NonFinites) GetFNinf() float32 {
if m != nil && m.FNinf != nil {
return *m.FNinf
}
return 0
}
func (m *NonFinites) GetDNan() float64 {
if m != nil && m.DNan != nil {
return *m.DNan
}
return 0
}
func (m *NonFinites) GetDPinf() float64 {
if m != nil && m.DPinf != nil {
return *m.DPinf
}
return 0
}
func (m *NonFinites) GetDNinf() float64 {
if m != nil && m.DNinf != nil {
return *m.DNinf
}
return 0
}
// Test message for holding repeated primitives.
type Repeats struct {
RBool []bool `protobuf:"varint,1,rep,name=r_bool,json=rBool" json:"r_bool,omitempty"`
@@ -181,7 +239,7 @@ type Repeats struct {
func (m *Repeats) Reset() { *m = Repeats{} }
func (m *Repeats) String() string { return proto.CompactTextString(m) }
func (*Repeats) ProtoMessage() {}
func (*Repeats) Descriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{1} }
func (*Repeats) Descriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{2} }
func (m *Repeats) GetRBool() []bool {
if m != nil {
@@ -274,7 +332,7 @@ type Widget struct {
func (m *Widget) Reset() { *m = Widget{} }
func (m *Widget) String() string { return proto.CompactTextString(m) }
func (*Widget) ProtoMessage() {}
func (*Widget) Descriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{2} }
func (*Widget) Descriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{3} }
func (m *Widget) GetColor() Widget_Color {
if m != nil && m.Color != nil {
@@ -327,7 +385,7 @@ type Maps struct {
func (m *Maps) Reset() { *m = Maps{} }
func (m *Maps) String() string { return proto.CompactTextString(m) }
func (*Maps) ProtoMessage() {}
func (*Maps) Descriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{3} }
func (*Maps) Descriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{4} }
func (m *Maps) GetMInt64Str() map[int64]string {
if m != nil {
@@ -356,7 +414,7 @@ type MsgWithOneof struct {
func (m *MsgWithOneof) Reset() { *m = MsgWithOneof{} }
func (m *MsgWithOneof) String() string { return proto.CompactTextString(m) }
func (*MsgWithOneof) ProtoMessage() {}
func (*MsgWithOneof) Descriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{4} }
func (*MsgWithOneof) Descriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{5} }
type isMsgWithOneof_Union interface {
isMsgWithOneof_Union()
@@ -519,7 +577,7 @@ type Real struct {
func (m *Real) Reset() { *m = Real{} }
func (m *Real) String() string { return proto.CompactTextString(m) }
func (*Real) ProtoMessage() {}
func (*Real) Descriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{5} }
func (*Real) Descriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{6} }
var extRange_Real = []proto.ExtensionRange{
{Start: 100, End: 536870911},
@@ -545,7 +603,7 @@ type Complex struct {
func (m *Complex) Reset() { *m = Complex{} }
func (m *Complex) String() string { return proto.CompactTextString(m) }
func (*Complex) ProtoMessage() {}
func (*Complex) Descriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{6} }
func (*Complex) Descriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{7} }
var extRange_Complex = []proto.ExtensionRange{
{Start: 100, End: 536870911},
@@ -593,7 +651,7 @@ type KnownTypes struct {
func (m *KnownTypes) Reset() { *m = KnownTypes{} }
func (m *KnownTypes) String() string { return proto.CompactTextString(m) }
func (*KnownTypes) ProtoMessage() {}
func (*KnownTypes) Descriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{7} }
func (*KnownTypes) Descriptor() ([]byte, []int) { return fileDescriptorTestObjects, []int{8} }
func (m *KnownTypes) GetAn() *google_protobuf.Any {
if m != nil {
@@ -711,6 +769,7 @@ var E_Name = &proto.ExtensionDesc{
func init() {
proto.RegisterType((*Simple)(nil), "jsonpb.Simple")
proto.RegisterType((*NonFinites)(nil), "jsonpb.NonFinites")
proto.RegisterType((*Repeats)(nil), "jsonpb.Repeats")
proto.RegisterType((*Widget)(nil), "jsonpb.Widget")
proto.RegisterType((*Maps)(nil), "jsonpb.Maps")
@@ -726,76 +785,81 @@ func init() {
func init() { proto.RegisterFile("test_objects.proto", fileDescriptorTestObjects) }
var fileDescriptorTestObjects = []byte{
// 1128 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x95, 0xdd, 0x92, 0xdb, 0x34,
0x14, 0xc7, 0x6b, 0x3b, 0xce, 0x87, 0x92, 0x6e, 0x83, 0x66, 0xdb, 0xba, 0xa1, 0x50, 0x4f, 0x28,
0xc5, 0xb4, 0x34, 0x1d, 0xbc, 0x99, 0x0c, 0x53, 0xb8, 0xd9, 0x8f, 0x40, 0x19, 0xba, 0x65, 0x46,
0xdb, 0xa5, 0xdc, 0x65, 0x9c, 0x8d, 0x36, 0x75, 0x71, 0xac, 0x8c, 0x24, 0xef, 0x36, 0x03, 0x17,
0x7b, 0xcd, 0x35, 0xcf, 0xc0, 0x23, 0x70, 0xc1, 0x63, 0xf0, 0x00, 0x3c, 0x08, 0x57, 0xcc, 0x39,
0xb2, 0xe3, 0xdd, 0x64, 0x73, 0x15, 0x4b, 0xe7, 0x7f, 0xfe, 0x91, 0x7e, 0x3a, 0xd2, 0x21, 0x54,
0x73, 0xa5, 0x47, 0x62, 0xfc, 0x8e, 0x9f, 0x68, 0xd5, 0x9b, 0x4b, 0xa1, 0x05, 0xad, 0xbe, 0x53,
0x22, 0x9d, 0x8f, 0x3b, 0xf7, 0xa6, 0x42, 0x4c, 0x13, 0xfe, 0x0c, 0x67, 0xc7, 0xd9, 0xe9, 0xb3,
0x28, 0x5d, 0x18, 0x49, 0xe7, 0xe3, 0xd5, 0xd0, 0x24, 0x93, 0x91, 0x8e, 0x45, 0x9a, 0xc7, 0xef,
0xaf, 0xc6, 0x95, 0x96, 0xd9, 0x89, 0xce, 0xa3, 0x0f, 0x56, 0xa3, 0x3a, 0x9e, 0x71, 0xa5, 0xa3,
0xd9, 0x7c, 0x93, 0xfd, 0xb9, 0x8c, 0xe6, 0x73, 0x2e, 0xf3, 0x15, 0x76, 0xb6, 0xa7, 0x62, 0x2a,
0xf0, 0xf3, 0x19, 0x7c, 0x99, 0xd9, 0xee, 0x3f, 0x36, 0xa9, 0x1e, 0xc5, 0xb3, 0x79, 0xc2, 0xe9,
0x6d, 0x52, 0x15, 0xa3, 0xb1, 0x10, 0x89, 0x67, 0xf9, 0x56, 0x50, 0x67, 0xae, 0xd8, 0x13, 0x22,
0xa1, 0x77, 0x49, 0x4d, 0x8c, 0xe2, 0x54, 0xef, 0x84, 0x9e, 0xed, 0x5b, 0x81, 0xcb, 0xaa, 0xe2,
0x7b, 0x18, 0x2d, 0x03, 0x83, 0xbe, 0xe7, 0xf8, 0x56, 0xe0, 0x98, 0xc0, 0xa0, 0x4f, 0xef, 0x91,
0xba, 0x18, 0x65, 0x26, 0xa5, 0xe2, 0x5b, 0xc1, 0x4d, 0x56, 0x13, 0xc7, 0x38, 0x2c, 0x43, 0x83,
0xbe, 0xe7, 0xfa, 0x56, 0x50, 0xc9, 0x43, 0x45, 0x96, 0x32, 0x59, 0x55, 0xdf, 0x0a, 0x3e, 0x60,
0x35, 0x71, 0x74, 0x29, 0x4b, 0x99, 0xac, 0x9a, 0x6f, 0x05, 0x34, 0x0f, 0x0d, 0xfa, 0x66, 0x11,
0xa7, 0x89, 0x88, 0xb4, 0x57, 0xf7, 0xad, 0xc0, 0x66, 0x55, 0xf1, 0x2d, 0x8c, 0x4c, 0xce, 0x44,
0x64, 0xe3, 0x84, 0x7b, 0x0d, 0xdf, 0x0a, 0x2c, 0x56, 0x13, 0x07, 0x38, 0xcc, 0xed, 0xb4, 0x8c,
0xd3, 0xa9, 0x47, 0x7c, 0x2b, 0x68, 0x80, 0x1d, 0x0e, 0x8d, 0xdd, 0x78, 0xa1, 0xb9, 0xf2, 0x9a,
0xbe, 0x15, 0xb4, 0x58, 0x55, 0xec, 0xc1, 0x88, 0x3e, 0x21, 0x2d, 0x31, 0x3a, 0x89, 0x94, 0xce,
0xa3, 0x2d, 0x88, 0xee, 0x35, 0xfe, 0xfb, 0xf7, 0x81, 0x8b, 0x02, 0x46, 0xc4, 0x7e, 0xa4, 0x34,
0x7e, 0x77, 0xff, 0xb4, 0x49, 0x8d, 0xf1, 0x39, 0x8f, 0xb4, 0x02, 0xaa, 0xb2, 0xa0, 0xea, 0x00,
0x55, 0x59, 0x50, 0x95, 0x4b, 0xaa, 0x0e, 0x50, 0x95, 0x4b, 0xaa, 0x72, 0x49, 0xd5, 0x01, 0xaa,
0x72, 0x49, 0x55, 0x96, 0x54, 0x1d, 0xa0, 0x2a, 0x4b, 0xaa, 0xb2, 0xa4, 0xea, 0x00, 0x55, 0x59,
0x52, 0x95, 0x25, 0x55, 0x07, 0xa8, 0xca, 0xa3, 0x4b, 0x59, 0x4b, 0xaa, 0x0e, 0x50, 0x95, 0x25,
0x55, 0xb9, 0xa4, 0xea, 0x00, 0x55, 0xb9, 0xa4, 0x2a, 0x4b, 0xaa, 0x0e, 0x50, 0x95, 0x25, 0x55,
0x59, 0x52, 0x75, 0x80, 0xaa, 0x2c, 0xa9, 0xca, 0x25, 0x55, 0x07, 0xa8, 0x4a, 0x03, 0xea, 0x2f,
0x9b, 0x54, 0xdf, 0xc4, 0x93, 0x29, 0xd7, 0xf4, 0x31, 0x71, 0x4f, 0x44, 0x22, 0x24, 0x16, 0xdf,
0x56, 0xb8, 0xdd, 0x33, 0x17, 0xaa, 0x67, 0xc2, 0xbd, 0x7d, 0x88, 0x31, 0x23, 0xa1, 0x4f, 0xc1,
0xcf, 0xa8, 0x01, 0xde, 0x26, 0x75, 0x55, 0xe2, 0x2f, 0x7d, 0x44, 0xaa, 0x0a, 0x4b, 0x1c, 0x4f,
0xbb, 0x19, 0x6e, 0x15, 0x6a, 0x53, 0xf8, 0x2c, 0x8f, 0xd2, 0xcf, 0x0d, 0x10, 0x54, 0xc2, 0x3a,
0xd7, 0x95, 0x00, 0x28, 0x97, 0xd6, 0xa4, 0x39, 0x60, 0x6f, 0x1b, 0x3d, 0x6f, 0x15, 0xca, 0xfc,
0xdc, 0x59, 0x11, 0xa7, 0x5f, 0x90, 0x86, 0x1c, 0x15, 0xe2, 0xdb, 0x68, 0xbb, 0x26, 0xae, 0xcb,
0xfc, 0xab, 0xfb, 0x29, 0x71, 0xcd, 0xa2, 0x6b, 0xc4, 0x61, 0xc3, 0x83, 0xf6, 0x0d, 0xda, 0x20,
0xee, 0x77, 0x6c, 0x38, 0x7c, 0xd5, 0xb6, 0x68, 0x9d, 0x54, 0xf6, 0x5e, 0x1e, 0x0f, 0xdb, 0x76,
0xf7, 0x0f, 0x9b, 0x54, 0x0e, 0xa3, 0xb9, 0xa2, 0x5f, 0x93, 0xe6, 0xcc, 0x94, 0x0b, 0xb0, 0xc7,
0x1a, 0x6b, 0x86, 0x1f, 0x16, 0xfe, 0x20, 0xe9, 0x1d, 0x62, 0xfd, 0x1c, 0x69, 0x39, 0x4c, 0xb5,
0x5c, 0xb0, 0xc6, 0xac, 0x18, 0xd3, 0x5d, 0x72, 0x73, 0x86, 0xb5, 0x59, 0xec, 0xda, 0xc6, 0xf4,
0x8f, 0xae, 0xa6, 0x43, 0xbd, 0x9a, 0x6d, 0x1b, 0x83, 0xe6, 0xac, 0x9c, 0xe9, 0x7c, 0x43, 0xb6,
0xae, 0xfa, 0xd3, 0x36, 0x71, 0x7e, 0xe1, 0x0b, 0x3c, 0x46, 0x87, 0xc1, 0x27, 0xdd, 0x26, 0xee,
0x59, 0x94, 0x64, 0x1c, 0xdf, 0x8f, 0x06, 0x33, 0x83, 0xe7, 0xf6, 0x57, 0x56, 0xe7, 0x15, 0x69,
0xaf, 0xda, 0x5f, 0xce, 0xaf, 0x9b, 0xfc, 0x87, 0x97, 0xf3, 0xd7, 0x0f, 0xa5, 0xf4, 0xeb, 0xfe,
0x6e, 0x91, 0xd6, 0xa1, 0x9a, 0xbe, 0x89, 0xf5, 0xdb, 0x1f, 0x53, 0x2e, 0x4e, 0xe9, 0x1d, 0xe2,
0xea, 0x58, 0x27, 0x1c, 0xed, 0x1a, 0x2f, 0x6e, 0x30, 0x33, 0xa4, 0x1e, 0xa9, 0xaa, 0x28, 0x89,
0xe4, 0x02, 0x3d, 0x9d, 0x17, 0x37, 0x58, 0x3e, 0xa6, 0x1d, 0x52, 0xdb, 0x17, 0x19, 0xac, 0x04,
0x5f, 0x35, 0xc8, 0x29, 0x26, 0xe8, 0x27, 0xa4, 0xf5, 0x56, 0xcc, 0xf8, 0x28, 0x9a, 0x4c, 0x24,
0x57, 0x0a, 0x1f, 0x37, 0x10, 0x34, 0x61, 0x76, 0xd7, 0x4c, 0xee, 0xd5, 0x88, 0x9b, 0xa5, 0xb1,
0x48, 0xbb, 0x8f, 0x48, 0x85, 0xf1, 0x28, 0x29, 0xb7, 0x6f, 0xe1, 0x33, 0x64, 0x06, 0x8f, 0xeb,
0xf5, 0x49, 0xfb, 0xe2, 0xe2, 0xe2, 0xc2, 0xee, 0x9e, 0xc3, 0x3f, 0xc2, 0x4e, 0xde, 0xd3, 0xfb,
0xa4, 0x11, 0xcf, 0xa2, 0x69, 0x9c, 0xc2, 0xca, 0x8c, 0xbc, 0x9c, 0x28, 0x53, 0xc2, 0x03, 0xb2,
0x25, 0x79, 0x94, 0x8c, 0xf8, 0x7b, 0xcd, 0x53, 0x15, 0x8b, 0x94, 0xb6, 0xca, 0x92, 0x8a, 0x12,
0xef, 0xd7, 0xab, 0x35, 0x99, 0xdb, 0xb3, 0x9b, 0x90, 0x34, 0x2c, 0x72, 0xba, 0x7f, 0xbb, 0x84,
0xfc, 0x90, 0x8a, 0xf3, 0xf4, 0xf5, 0x62, 0xce, 0x15, 0x7d, 0x48, 0xec, 0x28, 0xf5, 0xb6, 0x30,
0x75, 0xbb, 0x67, 0xba, 0x49, 0xaf, 0xe8, 0x26, 0xbd, 0xdd, 0x74, 0xc1, 0xec, 0x28, 0xa5, 0x4f,
0x88, 0x33, 0xc9, 0xcc, 0x2d, 0x6d, 0x86, 0xf7, 0xd6, 0x64, 0x07, 0x79, 0x4f, 0x63, 0xa0, 0xa2,
0x9f, 0x11, 0x5b, 0x69, 0x7c, 0x2b, 0x9b, 0xe1, 0xdd, 0x35, 0xed, 0x11, 0xf6, 0x37, 0x66, 0x2b,
0xb8, 0xfd, 0xb6, 0x56, 0xf9, 0xf9, 0x76, 0xd6, 0x84, 0xaf, 0x8b, 0x56, 0xc7, 0x6c, 0xad, 0x40,
0x9b, 0x9c, 0x79, 0xb7, 0x36, 0x68, 0x5f, 0xc6, 0x4a, 0xff, 0x04, 0x84, 0x99, 0x9d, 0x9c, 0xd1,
0x80, 0x38, 0x67, 0x51, 0xe2, 0xb5, 0x51, 0x7c, 0x67, 0x4d, 0x6c, 0x84, 0x20, 0xa1, 0x3d, 0xe2,
0x4c, 0xc6, 0x09, 0x9e, 0x79, 0x33, 0xbc, 0xbf, 0xbe, 0x2f, 0x7c, 0xe4, 0x72, 0xfd, 0x64, 0x9c,
0xd0, 0xa7, 0xc4, 0x39, 0x4d, 0x34, 0x96, 0x00, 0x5c, 0xb8, 0x55, 0x3d, 0x3e, 0x97, 0xb9, 0xfc,
0x34, 0xd1, 0x20, 0x8f, 0xf3, 0x9e, 0x77, 0x9d, 0x1c, 0xaf, 0x50, 0x2e, 0x8f, 0x07, 0x7d, 0x58,
0x4d, 0x36, 0xe8, 0x63, 0x1f, 0xbc, 0x6e, 0x35, 0xc7, 0x97, 0xf5, 0xd9, 0xa0, 0x8f, 0xf6, 0x3b,
0x21, 0x36, 0xc7, 0x0d, 0xf6, 0x3b, 0x61, 0x61, 0xbf, 0x13, 0xa2, 0xfd, 0x4e, 0x88, 0x1d, 0x73,
0x93, 0xfd, 0x52, 0x9f, 0xa1, 0xbe, 0x82, 0x2d, 0xac, 0xb1, 0x01, 0x3a, 0xdc, 0x61, 0x23, 0x47,
0x1d, 0xf8, 0xc3, 0x6b, 0x44, 0x36, 0xf8, 0x9b, 0xb6, 0x90, 0xfb, 0x2b, 0x2d, 0xe9, 0x97, 0xc4,
0x2d, 0x9b, 0xee, 0x75, 0x1b, 0xc0, 0x76, 0x61, 0x12, 0x8c, 0xf2, 0xb9, 0x4f, 0x2a, 0x69, 0x34,
0xe3, 0x2b, 0x85, 0xff, 0x1b, 0xbe, 0x30, 0x18, 0xf9, 0xd9, 0xfd, 0x3f, 0x00, 0x00, 0xff, 0xff,
0xa5, 0x08, 0x41, 0xc3, 0xa9, 0x09, 0x00, 0x00,
// 1206 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x56, 0xcf, 0x72, 0x13, 0xc7,
0x13, 0x66, 0x77, 0xb5, 0xfa, 0xd3, 0x32, 0x46, 0xbf, 0xc1, 0xc0, 0xa2, 0x1f, 0x09, 0x2a, 0x85,
0x10, 0x05, 0x82, 0xa8, 0xc8, 0x2a, 0x55, 0x8a, 0xe4, 0x82, 0xb1, 0x09, 0xa9, 0x80, 0x93, 0x1a,
0x43, 0xc8, 0x4d, 0xb5, 0xf2, 0xae, 0xc4, 0x92, 0xd5, 0x8c, 0x6a, 0x66, 0xd6, 0xa0, 0x4a, 0x0e,
0x3e, 0xe7, 0x98, 0xca, 0x33, 0xe4, 0x11, 0x72, 0xc8, 0x63, 0xe4, 0x01, 0xf2, 0x20, 0x39, 0xa5,
0xba, 0x67, 0x57, 0x6b, 0x2c, 0x74, 0xf2, 0x76, 0xf7, 0xf7, 0x7d, 0x9e, 0x99, 0xaf, 0x67, 0x5a,
0xc0, 0x4c, 0xac, 0xcd, 0x58, 0x4e, 0x5e, 0xc7, 0xc7, 0x46, 0xf7, 0x17, 0x4a, 0x1a, 0xc9, 0xaa,
0xaf, 0xb5, 0x14, 0x8b, 0x49, 0xfb, 0xfa, 0x4c, 0xca, 0x59, 0x1a, 0xdf, 0xa7, 0xec, 0x24, 0x9b,
0xde, 0x0f, 0xc5, 0xd2, 0x42, 0xda, 0x1f, 0x9e, 0x2f, 0x45, 0x99, 0x0a, 0x4d, 0x22, 0x45, 0x5e,
0xbf, 0x71, 0xbe, 0xae, 0x8d, 0xca, 0x8e, 0x4d, 0x5e, 0xbd, 0x79, 0xbe, 0x6a, 0x92, 0x79, 0xac,
0x4d, 0x38, 0x5f, 0x6c, 0x92, 0x7f, 0xa3, 0xc2, 0xc5, 0x22, 0x56, 0xf9, 0x0a, 0xdb, 0x3b, 0x33,
0x39, 0x93, 0xf4, 0x79, 0x1f, 0xbf, 0x6c, 0xb6, 0xfb, 0xb7, 0x0b, 0xd5, 0xa3, 0x64, 0xbe, 0x48,
0x63, 0x76, 0x05, 0xaa, 0x72, 0x3c, 0x91, 0x32, 0x0d, 0x9c, 0x8e, 0xd3, 0xab, 0x73, 0x5f, 0xee,
0x49, 0x99, 0xb2, 0x6b, 0x50, 0x93, 0xe3, 0x44, 0x98, 0xdd, 0x41, 0xe0, 0x76, 0x9c, 0x9e, 0xcf,
0xab, 0xf2, 0x1b, 0x8c, 0x56, 0x85, 0xd1, 0x30, 0xf0, 0x3a, 0x4e, 0xcf, 0xb3, 0x85, 0xd1, 0x90,
0x5d, 0x87, 0xba, 0x1c, 0x67, 0x96, 0x52, 0xe9, 0x38, 0xbd, 0x8b, 0xbc, 0x26, 0x5f, 0x50, 0x58,
0x96, 0x46, 0xc3, 0xc0, 0xef, 0x38, 0xbd, 0x4a, 0x5e, 0x2a, 0x58, 0xda, 0xb2, 0xaa, 0x1d, 0xa7,
0xf7, 0x3f, 0x5e, 0x93, 0x47, 0x67, 0x58, 0xda, 0xb2, 0x6a, 0x1d, 0xa7, 0xc7, 0xf2, 0xd2, 0x68,
0x68, 0x17, 0x31, 0x4d, 0x65, 0x68, 0x82, 0x7a, 0xc7, 0xe9, 0xb9, 0xbc, 0x2a, 0x1f, 0x63, 0x64,
0x39, 0x91, 0xcc, 0x26, 0x69, 0x1c, 0x34, 0x3a, 0x4e, 0xcf, 0xe1, 0x35, 0xb9, 0x4f, 0x61, 0x2e,
0x67, 0x54, 0x22, 0x66, 0x01, 0x74, 0x9c, 0x5e, 0x03, 0xe5, 0x28, 0xb4, 0x72, 0x93, 0xa5, 0x89,
0x75, 0xd0, 0xec, 0x38, 0xbd, 0x2d, 0x5e, 0x95, 0x7b, 0x18, 0xb1, 0xbb, 0xb0, 0x25, 0xc7, 0xc7,
0xa1, 0x36, 0x79, 0x75, 0x0b, 0xab, 0x7b, 0x8d, 0x7f, 0xff, 0xb9, 0xe9, 0x13, 0x80, 0x83, 0x7c,
0x14, 0x6a, 0x43, 0xdf, 0xdd, 0xdf, 0x1c, 0x80, 0x43, 0x29, 0x1e, 0x27, 0x22, 0x41, 0xee, 0x65,
0xf0, 0xa7, 0x63, 0x11, 0x0a, 0x3a, 0x57, 0x97, 0x57, 0xa6, 0x87, 0xa1, 0xc0, 0xd3, 0x9e, 0x8e,
0x17, 0x89, 0x98, 0xd2, 0xa9, 0xba, 0xdc, 0x9f, 0x7e, 0x9f, 0x88, 0xa9, 0x4d, 0x0b, 0x4c, 0x7b,
0x79, 0xfa, 0x10, 0xd3, 0x97, 0xc1, 0x8f, 0x48, 0xa2, 0x42, 0x5b, 0xa9, 0x44, 0xb9, 0x44, 0x64,
0x25, 0x7c, 0xca, 0xfa, 0x51, 0x21, 0x11, 0x59, 0x89, 0x6a, 0x9e, 0x46, 0x89, 0xee, 0x1f, 0x2e,
0xd4, 0x78, 0xbc, 0x88, 0x43, 0xa3, 0x11, 0xa2, 0x0a, 0xab, 0x3d, 0xb4, 0x5a, 0x15, 0x56, 0xab,
0x95, 0xd5, 0x1e, 0x5a, 0xad, 0x56, 0x56, 0xab, 0x95, 0xd5, 0x1e, 0x5a, 0xad, 0x56, 0x56, 0xab,
0xd2, 0x6a, 0x0f, 0xad, 0x56, 0xa5, 0xd5, 0xaa, 0xb4, 0xda, 0x43, 0xab, 0x55, 0x69, 0xb5, 0x2a,
0xad, 0xf6, 0xd0, 0x6a, 0x75, 0x74, 0x86, 0xb5, 0xb2, 0xda, 0x43, 0xab, 0x55, 0x69, 0xb5, 0x5a,
0x59, 0xed, 0xa1, 0xd5, 0x6a, 0x65, 0xb5, 0x2a, 0xad, 0xf6, 0xd0, 0x6a, 0x55, 0x5a, 0xad, 0x4a,
0xab, 0x3d, 0xb4, 0x5a, 0x95, 0x56, 0xab, 0x95, 0xd5, 0x1e, 0x5a, 0xad, 0xac, 0x7b, 0x7f, 0xba,
0x50, 0x7d, 0x99, 0x44, 0xb3, 0xd8, 0xb0, 0x3b, 0xe0, 0x1f, 0xcb, 0x54, 0x2a, 0x72, 0x6e, 0x7b,
0xb0, 0xd3, 0xb7, 0xb7, 0xbc, 0x6f, 0xcb, 0xfd, 0x47, 0x58, 0xe3, 0x16, 0xc2, 0xee, 0xa1, 0x9e,
0x45, 0xe3, 0xe1, 0x6d, 0x42, 0x57, 0x15, 0xfd, 0x65, 0xb7, 0xa1, 0xaa, 0xe9, 0xde, 0x51, 0x0b,
0x36, 0x07, 0xdb, 0x05, 0xda, 0xde, 0x46, 0x9e, 0x57, 0xd9, 0xa7, 0xf6, 0x40, 0x08, 0x89, 0xeb,
0x5c, 0x47, 0xe2, 0x01, 0xe5, 0xd0, 0x9a, 0xb2, 0x06, 0x07, 0x3b, 0xa4, 0x79, 0xa9, 0x40, 0xe6,
0xbe, 0xf3, 0xa2, 0xce, 0x3e, 0x83, 0x86, 0x1a, 0x17, 0xe0, 0x2b, 0x24, 0xbb, 0x06, 0xae, 0xab,
0xfc, 0xab, 0xfb, 0x31, 0xf8, 0x76, 0xd1, 0x35, 0xf0, 0xf8, 0xc1, 0x7e, 0xeb, 0x02, 0x6b, 0x80,
0xff, 0x35, 0x3f, 0x38, 0x38, 0x6c, 0x39, 0xac, 0x0e, 0x95, 0xbd, 0xa7, 0x2f, 0x0e, 0x5a, 0x6e,
0xf7, 0x77, 0x17, 0x2a, 0xcf, 0xc2, 0x85, 0x66, 0x5f, 0x42, 0x73, 0x6e, 0xdb, 0x05, 0xcf, 0x9e,
0x7a, 0xac, 0x39, 0xf8, 0x7f, 0xa1, 0x8f, 0x90, 0xfe, 0x33, 0xea, 0x9f, 0x23, 0xa3, 0x0e, 0x84,
0x51, 0x4b, 0xde, 0x98, 0x17, 0x31, 0x7b, 0x08, 0x17, 0xe7, 0xd4, 0x9b, 0xc5, 0xae, 0x5d, 0xa2,
0x7f, 0xf0, 0x2e, 0x1d, 0xfb, 0xd5, 0x6e, 0xdb, 0x0a, 0x34, 0xe7, 0x65, 0xa6, 0xfd, 0x15, 0x6c,
0xbf, 0xab, 0xcf, 0x5a, 0xe0, 0xfd, 0x14, 0x2f, 0xc9, 0x46, 0x8f, 0xe3, 0x27, 0xdb, 0x01, 0xff,
0x24, 0x4c, 0xb3, 0x98, 0xae, 0x5f, 0x83, 0xdb, 0xe0, 0x81, 0xfb, 0x85, 0xd3, 0x3e, 0x84, 0xd6,
0x79, 0xf9, 0xb3, 0xfc, 0xba, 0xe5, 0xdf, 0x3a, 0xcb, 0x5f, 0x37, 0xa5, 0xd4, 0xeb, 0xfe, 0xea,
0xc0, 0xd6, 0x33, 0x3d, 0x7b, 0x99, 0x98, 0x57, 0xdf, 0x89, 0x58, 0x4e, 0xd9, 0x55, 0xf0, 0x4d,
0x62, 0xd2, 0x98, 0xe4, 0x1a, 0x4f, 0x2e, 0x70, 0x1b, 0xb2, 0x00, 0xaa, 0x3a, 0x4c, 0x43, 0xb5,
0x24, 0x4d, 0xef, 0xc9, 0x05, 0x9e, 0xc7, 0xac, 0x0d, 0xb5, 0x47, 0x32, 0xc3, 0x95, 0xd0, 0xb3,
0x80, 0x9c, 0x22, 0xc1, 0x3e, 0x82, 0xad, 0x57, 0x72, 0x1e, 0x8f, 0xc3, 0x28, 0x52, 0xb1, 0xd6,
0xf4, 0x42, 0x20, 0xa0, 0x89, 0xd9, 0x87, 0x36, 0xb9, 0x57, 0x03, 0x3f, 0x13, 0x89, 0x14, 0xdd,
0xdb, 0x50, 0xe1, 0x71, 0x98, 0x96, 0xdb, 0x77, 0xec, 0x1b, 0x41, 0xc1, 0x9d, 0x7a, 0x3d, 0x6a,
0x9d, 0x9e, 0x9e, 0x9e, 0xba, 0xdd, 0x37, 0xf8, 0x1f, 0x71, 0x27, 0x6f, 0xd9, 0x0d, 0x68, 0x24,
0xf3, 0x70, 0x96, 0x08, 0x5c, 0x99, 0x85, 0x97, 0x89, 0x92, 0x32, 0xd8, 0x87, 0x6d, 0x15, 0x87,
0xe9, 0x38, 0x7e, 0x6b, 0x62, 0xa1, 0x13, 0x29, 0xd8, 0x56, 0xd9, 0x52, 0x61, 0x1a, 0xfc, 0xfc,
0x6e, 0x4f, 0xe6, 0xf2, 0xfc, 0x22, 0x92, 0x0e, 0x0a, 0x4e, 0xf7, 0x2f, 0x1f, 0xe0, 0x5b, 0x21,
0xdf, 0x88, 0xe7, 0xcb, 0x45, 0xac, 0xd9, 0x2d, 0x70, 0x43, 0x11, 0x6c, 0x13, 0x75, 0xa7, 0x6f,
0x47, 0x5c, 0xbf, 0x18, 0x71, 0xfd, 0x87, 0x62, 0xc9, 0xdd, 0x50, 0xb0, 0xbb, 0xe0, 0x45, 0x99,
0xbd, 0xa5, 0xcd, 0xc1, 0xf5, 0x35, 0xd8, 0x7e, 0x3e, 0x68, 0x39, 0xa2, 0xd8, 0x27, 0xe0, 0x6a,
0x43, 0x0f, 0x78, 0x73, 0x70, 0x6d, 0x0d, 0x7b, 0x44, 0x43, 0x97, 0xbb, 0x1a, 0x6f, 0xbf, 0x6b,
0x74, 0xee, 0x6f, 0x7b, 0x0d, 0xf8, 0xbc, 0x98, 0xbf, 0xdc, 0x35, 0x1a, 0xb1, 0xe9, 0x49, 0x70,
0x69, 0x03, 0xf6, 0x69, 0xa2, 0xcd, 0x0f, 0x78, 0xc2, 0xdc, 0x4d, 0x4f, 0x58, 0x0f, 0xbc, 0x93,
0x30, 0x0d, 0x5a, 0x04, 0xbe, 0xba, 0x06, 0xb6, 0x40, 0x84, 0xb0, 0x3e, 0x78, 0xd1, 0x24, 0x25,
0xcf, 0x9b, 0x83, 0x1b, 0xeb, 0xfb, 0xa2, 0x47, 0x2e, 0xc7, 0x47, 0x93, 0x94, 0xdd, 0x03, 0x6f,
0x9a, 0x1a, 0x6a, 0x01, 0xbc, 0x70, 0xe7, 0xf1, 0xf4, 0x5c, 0xe6, 0xf0, 0x69, 0x6a, 0x10, 0x9e,
0xe4, 0x83, 0xf8, 0x7d, 0x70, 0xba, 0x42, 0x39, 0x3c, 0x19, 0x0d, 0x71, 0x35, 0xd9, 0x68, 0x48,
0x53, 0xe5, 0x7d, 0xab, 0x79, 0x71, 0x16, 0x9f, 0x8d, 0x86, 0x24, 0xbf, 0x3b, 0xa0, 0x89, 0xbd,
0x41, 0x7e, 0x77, 0x50, 0xc8, 0xef, 0x0e, 0x48, 0x7e, 0x77, 0x40, 0x63, 0x7c, 0x93, 0xfc, 0x0a,
0x9f, 0x11, 0xbe, 0x42, 0x23, 0xac, 0xb1, 0xe1, 0xd0, 0xf1, 0x0e, 0x5b, 0x38, 0xe1, 0x50, 0x1f,
0x5f, 0x23, 0xd8, 0xa0, 0x6f, 0xc7, 0x42, 0xae, 0xaf, 0x8d, 0x62, 0x9f, 0x83, 0x5f, 0xfe, 0x12,
0x78, 0xdf, 0x06, 0x68, 0x5c, 0x58, 0x82, 0x45, 0x3e, 0xe8, 0x40, 0x45, 0x84, 0xf3, 0xf8, 0x5c,
0xe3, 0xff, 0x42, 0x2f, 0x0c, 0x55, 0x7e, 0xf4, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x9a, 0xa6,
0x21, 0x68, 0x3e, 0x0a, 0x00, 0x00,
}

140
vendor/github.com/gogo/protobuf/jsonpb/jsonpb_test_proto/test_objects.proto generated vendored
View File

@@ -1,140 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2015 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
syntax = "proto2";
import "google/protobuf/any.proto";
import "google/protobuf/duration.proto";
import "google/protobuf/struct.proto";
import "google/protobuf/timestamp.proto";
import "google/protobuf/wrappers.proto";
package jsonpb;
import weak "gogoproto/gogo.proto";
// Test message for holding primitive types.
message Simple {
optional bool o_bool = 1;
optional int32 o_int32 = 2;
optional int64 o_int64 = 3;
optional uint32 o_uint32 = 4;
optional uint64 o_uint64 = 5;
optional sint32 o_sint32 = 6;
optional sint64 o_sint64 = 7;
optional float o_float = 8;
optional double o_double = 9;
optional string o_string = 10;
optional bytes o_bytes = 11;
optional bytes o_cast_bytes = 12 [(gogoproto.casttype) = "Bytes"];
}
// Test message for holding repeated primitives.
message Repeats {
repeated bool r_bool = 1;
repeated int32 r_int32 = 2;
repeated int64 r_int64 = 3;
repeated uint32 r_uint32 = 4;
repeated uint64 r_uint64 = 5;
repeated sint32 r_sint32 = 6;
repeated sint64 r_sint64 = 7;
repeated float r_float = 8;
repeated double r_double = 9;
repeated string r_string = 10;
repeated bytes r_bytes = 11;
}
// Test message for holding enums and nested messages.
message Widget {
enum Color {
RED = 0;
GREEN = 1;
BLUE = 2;
};
optional Color color = 1;
repeated Color r_color = 2;
optional Simple simple = 10;
repeated Simple r_simple = 11;
optional Repeats repeats = 20;
repeated Repeats r_repeats = 21;
}
message Maps {
map<int64, string> m_int64_str = 1;
map<bool, Simple> m_bool_simple = 2;
}
message MsgWithOneof {
oneof union {
string title = 1;
int64 salary = 2;
string Country = 3;
string home_address = 4;
}
}
message Real {
optional double value = 1;
extensions 100 to max;
}
extend Real {
optional string name = 124;
}
message Complex {
extend Real {
optional Complex real_extension = 123;
}
optional double imaginary = 1;
extensions 100 to max;
}
message KnownTypes {
optional google.protobuf.Any an = 14;
optional google.protobuf.Duration dur = 1;
optional google.protobuf.Struct st = 12;
optional google.protobuf.Timestamp ts = 2;
optional google.protobuf.ListValue lv = 15;
optional google.protobuf.Value val = 16;
optional google.protobuf.DoubleValue dbl = 3;
optional google.protobuf.FloatValue flt = 4;
optional google.protobuf.Int64Value i64 = 5;
optional google.protobuf.UInt64Value u64 = 6;
optional google.protobuf.Int32Value i32 = 7;
optional google.protobuf.UInt32Value u32 = 8;
optional google.protobuf.BoolValue bool = 9;
optional google.protobuf.StringValue str = 10;
optional google.protobuf.BytesValue bytes = 11;
}